Java 复习 —— 锁以及线程之间的通讯

1、Lock

1）1.5版本之后出现，java.util.concurrent.locks.Lock

2） Lock 实现提供了比使用 synchronized 方法和语句可获得的更广泛的锁定操作。此实现允许更灵活的结构，可以具有差别很大的属性，可以支持多个相关的 Condition 对象。锁是控制多个线程对共享资源进行访问的工具。通常，锁提供了对共享资源的独占访问。一次只能有一个线程获得锁，对共享资源的所有访问都需要首先获得锁。不过，某些锁可能允许对共享资源并发访问，如 ReadWriteLock 的读取锁。

3）一般使用的Lock替代synchronized的代码如下：

     private Lock l = new ReentrantLock(); 
     l.lock();
     try {
         // access the resource protected by this lock
     } finally {
         l.unlock();
     }

4）和synchronized一样，也可以在线程之间进行通讯，如下代码：

class Data {
    private int number = 0;// 共享变量
    private Lock lock = new ReentrantLock(); // 一种互斥锁
    private Condition c1 = lock.newCondition(); // 锁上的一个条
    private Condition c2 = lock.newCondition(); // 锁上的另一个条件
    
    public Data(){
        System.out.println( c1 == c2); // 返回false，一个lock可以拥有多个独立的condition
    }
    
    public int increase(){
        lock.lock();// 对共享变量的操作必须加锁，而且线程通讯必须在拥有的锁的基础上
        try{
            if(number != 0){ // 这里没有必要使用循环判断，但是Object.wait必须在循环中判断
                try {
                    c1.await(); // 如果调用c1的方法，那么后面满足条件就应该对应唤醒c1
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            number++;
            c2.signal(); // 唤醒等待池中的c2
        }finally{
            lock.unlock(); // 所有的加锁之后的操作都必须使用规定的代码结构来完成
        }
        return number;
    }
    
    public int decrease(){
        lock.lock(); // 对共享变量的操作必须加锁，而且线程通讯必须在拥有的锁的基础上
        try{
            if(number != 1){// 这里没有必要使用循环判断，但是Object.wait必须在循环中判断
                try {
                    c2.await();  // 如果调用c2的方法，那么后面满足条件就应该对应唤醒c2
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            number--;
            c1.signal(); // 唤醒等待池中的c1
        }finally{
            lock.unlock();// 所有的加锁之后的操作都必须使用规定的代码结构来完成
        }
        return number;
    }
    
}