并发编程 - 可重入锁ReentrantLock

可重入锁

其实 synchronized 就是一个可重入锁，而 ReentrantLock 具有与使用 synchronized 方法和语句所访问的隐式监视器锁相同的一些基本行为和语义，但 ReentrantLock 的功能更强大。

可重入锁“可重入”的意思就是：当前线程获取了一个锁，就可以进入任何一块被此锁锁住的代码块。

如下列代码所示，Test类的所有函数都使用了 synchrounized，

• 当一个线程获得了方法1的锁，那么它会同时获取方法2的锁，
• 此时其它线程不论调用方法1，还是方法2都会进入等待，
• 其中，方法1调用了方法2，线程进入方法2的时候，不需要重新获取锁。

public class Test {
    public synchronized void printLine1() throws InterruptedException {
        Thread.sleep(3000);
        System.out.println("printLine1");
        printLine2();
    }

    public synchronized void printLine2() throws InterruptedException {
        Thread.sleep(100);
        System.out.println("printLine2");
    }
}

不可重入锁

有可重入锁，自然也有不可重入锁，确实存在不可重入锁的概念，不过在开发过程中，我也并未见过严格意义上的不可重入锁。如下列代码所示，尝试给每一个函数加不同的锁，这种写法显然是极不推荐的，容易因为编码失误产生死锁。

不需要刻意去纠结什么是不可重入锁，想要在代码中实现锁，同样必须用到 synchronized 、AbstractQueuedSynchronizer 等等，分析问题，使用API中已有的锁，往往就可以满足开发需求。

public class Test {
    private Object lockA = new Object(), lockB = new Object();

    public void printLine1() throws InterruptedException {
        synchronized (lockA) {
            System.out.print("printLine1");
            Thread.sleep(1000);
            printLine2();
        }
    }

    public void printLine2() throws InterruptedException {
        synchronized (lockB) {
            System.out.println("printLine2");
        }
    }
}

经典用法

ReentrantLock 可重入锁的最典型的代码如下，这种写法的特点同 synchronized，线程获取锁的时候，同时锁住了所有被锁包含的代码，其它线程都无法使用这些代码。

 class X {
   private final ReentrantLock lock = new ReentrantLock();
   // ...

   public void m() { 
     lock.lock();  // block until condition holds
     try {
       // ... method body
     } finally {
       lock.unlock()
     }
   }
 }

Demo（阻塞队列的简单实现）

ReentrantLock 的强大之处，还因为它提供了配套使用的 Condition 对象，使用 Condition 的 await() 函数和 signal()函数即可轻松地实现锁的释放和线程的唤醒。

ArrayBlockingQueue 就是一个使用了可重入锁的对象：

在调用take()函数取值的时候，这时候获取了锁，如果队列为空，则进入等待，
此时其它线程是可以调用put()函数，因为锁已经被释放。
当put()新的元素时，在take()函数中等待的队列被重新唤醒。

一般一个 ReentrantLock 配一个 Condition 就能满足开发需求，实际可以根据需求，创建多个 Condition 对象。

class BoundedBuffer {
    final Lock lock = new ReentrantLock();
    final Condition isFull = lock.newCondition();
    final Condition isEmpty = lock.newCondition();

    final LinkedList<Object> items = new LinkedList<>();

    public void put(Object x) throws InterruptedException {
        lock.lock();
        try {
            while (items.size() > 2)
                isFull.await();
            items.add(x);
            isEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public Object take() throws InterruptedException {
        lock.lock();
        try {
            while (items.size() == 0)
                isEmpty.await();
            isFull.signal();
            return items.poll();
        } finally {
            lock.unlock();
        }
    }
}