ReentrantLock

import java.util.concurrent.locks.ReentrantLock;  

public class Test {  
  
    public static void main(String[] args) {  
          
        final Count ct = new Count();  
        for (int i = 0; i < 2; i++) {  
            new Thread("get-"+i+":") {  
                @Override  
                public void run() {  
                    ct.get();  
                }  
            }.start();  
        }  
  
        for (int i = 0; i < 2; i++) {  
            new Thread("put-"+i+":") {  
                @Override  
                public void run() {  
                    ct.put();  
                }  
            }.start();  
        }  
          
    }  
}  
  
class Count {  
      
    /** 
     * 1、两个方法之间的锁是独立的，是两个不同的lock对象 
     * 2、把lock对象改成全局变量，两个方法用的同一个锁 
     */  
  
    final ReentrantLock lock = new ReentrantLock();  
    public void get() {  
  
          
        try {  
            lock.lock(); // 加锁  
            System.out.println(Thread.currentThread().getName() + " begin");  
            Thread.sleep(500L);// 模仿干活  
            System.out.println(Thread.currentThread().getName() + " end");  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }finally {
            lock.unlock(); // 解锁 
        }   
    }  
  
    public void put() {  
  
        try {  
            lock.lock(); // 加锁  
            System.out.println(Thread.currentThread().getName() + " begin");  
            Thread.sleep(500L);// 模仿干活  
            System.out.println(Thread.currentThread().getName() + " end");  
             
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }finally {
            lock.unlock(); // 解锁 
        }  
        
    } 
}

注意：

1、Lock必须手动开启和释放锁，synchronized不需要；

2、Lock只适用代码块锁，synchronized是对象之间的互斥关系；

上代码：

分析：

两个方法之间的锁是独立的情况下，每次执行的结果都不一样

如果把lock对象改为全局变量，两个方法用同一个对象锁，则每次运行的结果都是固定的。