Java Concurrency代码实例之四-锁

本文的读者应该是已经掌握了基本的Java多线程开发技巧，但不熟悉Java Concurrency包的程序员。本文是本系列的第四篇文章，前三篇文章请看这里：
https://zhuanlan.zhihu.com/p/26724352
https://zhuanlan.zhihu.com/p/27148381
https://zhuanlan.zhihu.com/p/27338395

1. 前言

按照用途与特性，Concurrency包中包含的工具被分为六类（外加一个工具类TimeUnit），即：
1. 执行者与线程池
2. 并发队列
3. 同步工具
4. 并发集合
5. 锁
6. 原子变量
本文介绍的是其中的锁，与synchronize关键字不同，并发包中的锁，其阻塞机制是调用Unsafe类提供的park和unpark方法，结合CAS原子语句，实现了比synchronize更加高效灵活的各种锁。

2. Unsafe类的park和unpark

在前文（https://zhuanlan.zhihu.com/p/27338395）中曾经详细介绍过Unsafe类的指针和CAS操作，这里再介绍一下它的park和unpark操作。

public native void park(boolean var1, long var2);public native void unpark(Object var1);

park方法用来阻塞一个线程，第一个参数用来指示后面的参数是绝对时间还是相对时间，true表示绝对时间，false表示从此刻开始后的相对时间。调用park的线程就阻塞在此处。
upark用来释放某个线程的阻塞，线程用参数var1表示。例子如下：

public class UnsafeParkExam {    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException {        Field f = Unsafe.class.getDeclaredField("theUnsafe");        f.setAccessible(true);        Unsafe unsafe = (Unsafe) f.get(null);        Thread t1 = new Thread() {            @Override            public void run() {                Thread.currentThread().setName("t1");                System.out.println(Thread.currentThread().getName() + " before park");                //park 100 seconds                unsafe.park(false, TimeUnit.NANOSECONDS.convert(100, TimeUnit.SECONDS));                System.out.println(Thread.currentThread().getName() + " after park");            }        };        Thread t2 = new Thread() {            @Override            public void run() {                try {                    Thread.currentThread().setName("t2");                    TimeUnit.SECONDS.sleep(1);                    System.out.println(Thread.currentThread().getName() + " unpark t1");                    unsafe.unpark(t1);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        };        Thread t3 = new Thread() {            @Override            public void run() {                Thread.currentThread().setName("t3");                System.out.println(Thread.currentThread().getName() + " park 5 seconds");                //park 5 seconds                unsafe.park(true, System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(5,TimeUnit.SECONDS));                System.out.println(Thread.currentThread().getName() + " after park");            }        };        t1.start();        t2.start();        t3.start();        try {            t1.join();            t2.join();            t3.join();        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

3. LockSupport

直接使用Unsafe还是有诸多不便之处，因此lock包提供了一个辅助类LockSupport来封装了park和unpark，例子如下：

public class LockSupportExam {    public static void main(String[] args) {        Thread t1 = new Thread() {            @Override            public void run() {                Thread.currentThread().setName("t1");                System.out.println(Thread.currentThread().getName() + " before park");                //park 100 seconds                LockSupport.parkNanos(TimeUnit.NANOSECONDS.convert(100, TimeUnit.SECONDS));                System.out.println(Thread.currentThread().getName() + " after park");            }        };        Thread t2 = new Thread() {            @Override            public void run() {                try {                    Thread.currentThread().setName("t2");                    TimeUnit.SECONDS.sleep(1);                    System.out.println(Thread.currentThread().getName() + " unpark t1");                    LockSupport.unpark(t1);                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        };        Thread t3 = new Thread() {            @Override            public void run() {                Thread.currentThread().setName("t3");                System.out.println(Thread.currentThread().getName() + " park 5 seconds");                //park 5 seconds                LockSupport.parkUntil(System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(5,TimeUnit.SECONDS));                System.out.println(Thread.currentThread().getName() + " after park");            }        };        t1.start();        t2.start();        t3.start();        try {            t1.join();            t2.join();            t3.join();        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

从例子中可以看出，使用LockSupport要比直接只用Unsafe更加便捷。除此之外，LockSupport还可以用来给线程设置一个Blocker对象，便于调试和检测线程，其原理是使用Unsafe的putObject方法直接设置Thread对象的parkBlocker属性，并在合适的时候读取这个Blocker对象，例子如下：

public class LockSupportBlockerExam {    public static void main(String[] args) {        Thread t3 = new Thread() {            @Override            public void run() {                Thread.currentThread().setName("t3");                System.out.println(Thread.currentThread().getName() + " park 5 seconds");                //park 5 seconds, set blocker                Object blocker = new String("Alex Wang");                LockSupport.parkUntil(blocker, System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(5, TimeUnit.SECONDS));                System.out.println(Thread.currentThread().getName() + " after park");            }        };        t3.start();        try {            Object t3_blocker = null;            while (t3_blocker == null) {                t3_blocker = LockSupport.getBlocker(t3);                TimeUnit.MILLISECONDS.sleep(10);            }            System.out.println("t3 blocker is :" + t3_blocker);            t3.join();        } catch (InterruptedException e) {            e.printStackTrace();        }    }}

4. 锁的核心AQS同步器

毫不夸张的说，各种锁ReentrantLock、ReentrantReadWriteLock以及各种同步器诸如Semaphore、CountDownLatch等等，其核心都是AbstractQueuedSynchronizer（AQS同步器）。要了解AQS的原理，仅仅看代码和JDK文档是不够的，其原理在这一篇论文（http://gee.cs.oswego.edu/dl/papers/aqs.pdf）中详细阐述了，强烈建议仔细阅读此论文。

4.1 使用AQS写一个排它锁

由于AQS非常复杂，从源代码入手很难看懂，最好的学习方法是看它是如何被使用的。这里有一个非常简单的例子SimpleLock，实现了一个最简单的排它锁。当有线程获得锁时，其他线程只能等待；当这个线程释放锁时，另一个线程可以竞争获取锁。

public class SimpleLock {    private static class Sync extends AbstractQueuedSynchronizer {        @Override        protected boolean tryAcquire(int ignore) {            return compareAndSetState(0, 1);        }        @Override        protected boolean tryRelease(int ignore) {            setState(0);            return true;        }        protected Sync() {            super();        }    }    private final Sync sync = new Sync();    public void lock() {        sync.acquire(1);    }    public void unlock() {        sync.release(1);    }    private static class MyThread extends Thread {        private final String name;        private final SimpleLock lock;        private MyThread(String name, SimpleLock lock) {            this.name = name;            this.lock = lock;        }        @Override        public void run() {            try {                lock.lock();                System.out.println(name + " get the lock");                TimeUnit.SECONDS.sleep(2);            } catch (InterruptedException e) {                e.printStackTrace();            } finally {                lock.unlock();                System.out.println(name + " release the lock");            }        }    }    public static void main(String[] args) {        final SimpleLock mutex = new SimpleLock();        MyThread t1 = new MyThread("t1", mutex);        MyThread t2 = new MyThread("t2", mutex);        MyThread t3 = new MyThread("t3", mutex);        t1.start();        t2.start();        t3.start();        try {            t1.join();            t2.join();            t3.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("main thread exit!");    }}

运行结果表明，通过简单的几行代码，就实行了一个锁的所有功能。
根据JUC（Java Util Concurrency）作者的建议，AQS的使用方法要遵循上面这个模式。一是使用一个内部类Sync来继承AQS，并实现AQS的相关方法，一般是tryAcquire和tryRelease（排它锁），或者tryAcquireShared和tryReleaseShared（共享锁）；二是在内部使用一个代理模式来实现锁的功能，这样做的好处是可以让暴露出的同步、互斥方法名由程序员自行决定，例如各种锁可以使用lock、unlock，Semaphore可以使用acquire和release，CountDownLatch可以使用await和countDown。

4.2 AQS基本原理

要实现一个同步器，需要三个条件：
1. 一个同步状态值，并可以原子化的操作这个状态值。显然，我们可以使用上一篇讲到的CAS方法来操作状态值；
2. 阻塞线程和解除阻塞线程的机制，可以用LockSupport来实现；
3. 维持一个阻塞线程的队列，并在队列的每个节点中存储线程的状态等信息。
AQS同时满足了这三个条件，首先，它提供了如下的状态值，以及相应的操作方法：

private volatile int state;protected final int getState() {    return state;}protected final void setState(int newState) {    state = newState;}protected final boolean compareAndSetState(int expect, int update) {    // See below for intrinsics setup to support this    return unsafe.compareAndSwapInt(this, stateOffset, expect, update);}

state是一个volatile int类型，除了getter和setter方法外，还提供了一个CAS方法，提供原子化的比较更新操作。一般来说，AQS认为state为0时，同步器处于释放状态，多个线程此刻可以竞争获取同步器；state不等于0时，同步器处于已获取状态，后续线程需进入队列，等待同步器（可重入的同步器允许获取同步器的线程再次进入同步器，并使用state进行计数）。当然，很多情况下，程序员也可自己定义state的值的含义，特别是在实现读写锁时，需要将state一分为二的用。
其次，LockSupport提供了阻塞和解除阻塞的功能。因此，所有同步器的阻塞操作其实都是基于LockSupport的，也就是基于Unsafe的park和unpark方法的。
第三，AQS内部提供了一个Node类型，它是用来形成“线程等待队列”的节点类型，以及一个由Node类型组成的队列。此队列的原理留待后续章节细说。

4.3 继承AQS时需要重写的方法

从上面的例子中可以看出，通过继承时重写了两个方法tryAcquire和tryRelease，就可以实现一个具体的同步器。通过研究AQS的原理可以得知，它将一些复杂的操作封装在自己内部，留待继承者重写的方法仅有以下5个（除去构造函数）：
1. tryAcquire

protected boolean tryAcquire(int arg) {    throw new UnsupportedOperationException();}

此方法是用来在多个线程竞争同步器时调用，作为AQS中acquire方法的第一个部分。若tryAcquire返回true，表明此线程获取了同步器；否则表明此线程没有获取同步器，而要进入队列等待同步器。在重写此方法时，仅需获取state的值，并通过CAS设置state的值，若成功则说明本线程竞争成功，否则说明线程竞争失败。
2. tryRelease

protected boolean tryRelease(int arg) {    throw new UnsupportedOperationException();}

此方法是用来释放同步器时调用，作为AQS中release方法的第一个部分。若tryRelease返回true，则表明当前线程可以正常释放同步器；否则不做其他操作。在重写此方法时，需要获取state的值，进行状态判断，然后依据具体情况将其设置为另一个值（一般设置为0）即可。
3. tryAcquireShared

protected int tryAcquireShared(int arg) {    throw new UnsupportedOperationException();}

此方法与tryAcquire非常类似，不同的是它被用来实现共享锁时调用。由于共享锁允许多个线程同时获取同步器，而且在释放时也可以同时释放多个线程。因此在重写tryAcquireShared时要特别注意state的定义和读写方法。
4. tryReleaseShared

protected boolean tryReleaseShared(int arg) {    throw new UnsupportedOperationException();}

此方法与tryRelease类似，不同的是它也被用来实现共享锁时调用。由于共享锁的特性，重写此方法时也要注意state的定义和读写方法。
5. isHeldExclusively

protected boolean isHeldExclusively() {    throw new UnsupportedOperationException();}

此方法在需要实现排它锁的Condition时重写。

4.4 排它锁的原理与流程

前面我们已经提供了一个最简单的排它锁SimpleLock，然而它的实现细节没有讲，下面我用两个图来说明，第一个图是lock的流程框架：

AQS已经把排它锁的加锁框架全部搭建好了，程序员只需要重写tryAcquire方法即可完成整个的功能。在看流程图的时候，要设想多个线程同时进入这个流程的样子。
第二个图是unlock的流程框架：

同样，AQS已经把解锁的框架全部搭建好了，程序员只需重写tryRelease方法即可实现排它锁的解锁。值得注意的是，排它锁被解锁后，仅有一个被阻塞的线程能够获得锁，其他线程依然在队列中等待。

4.5 初试共享锁

AQS不仅提供了排它锁，同时也提供了共享锁的框架。对于排它锁和共享锁，并没有明确的定义，此处根据本人自己的理解，给出一个定义。排它锁，即在一个时刻只有一个线程可以获取的锁，其他线程的加锁方法会被阻塞，直至拥有锁的线程释放该锁为止。共享锁，即在一个时刻允许多个线程同时获取的锁。根据场景的不同，可以构建多种不同类型的共享锁，有的共享锁允许定量的（n个）线程拥有锁，此外的线程在加锁时依然会被阻塞，每当一个线程释放一次锁，则后续的一个线程可以竞争获取该锁（例如Semaphore）；有的共享锁会阻塞所有的线程，但一旦执行某种释放操作，则所有被阻塞的线程会被同时唤醒（例如CountDownLatch）；有的共享锁需要与一个排它锁配合，实现对文件读写的各种同步（ReentrantReadWriteLock）。这些具体的同步器会在后续的章节或文章中介绍。
根据SimpleLock，我们再试着实现一个最简单的共享锁SimpleSharedLock，代码如下：

public class SimpleSharedLock {    private static class Sync extends AbstractQueuedSynchronizer {        @Override        protected int tryAcquireShared(int arg) {            return compareAndSetState(0, 1) ? 1 : -1;        }        @Override        protected boolean tryReleaseShared(int arg) {            setState(0);            return true;        }        protected Sync() {            super();        }    }    private final Sync sync = new Sync();    public void lock() {        sync.acquireShared(1);    }    public void unlock() {        sync.releaseShared(1);    }    private static class MyThread extends Thread {        private final String name;        private final SimpleSharedLock lock;        private MyThread(String name, SimpleSharedLock lock) {            this.name = name;            this.lock = lock;        }        @Override        public void run() {            try {                lock.lock();                System.out.println(name + " get the lock");                TimeUnit.SECONDS.sleep(2);            } catch (InterruptedException e) {                e.printStackTrace();            } finally {                lock.unlock();                System.out.println(name + " release the lock");            }        }    }    public static void main(String[] args) {        final SimpleSharedLock lock = new SimpleSharedLock();        MyThread t1 = new MyThread("t1", lock);        MyThread t2 = new MyThread("t2", lock);        MyThread t3 = new MyThread("t3", lock);        t1.start();        t2.start();        t3.start();        try {            t1.join();            t2.join();            t3.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("main thread exit!");    }}

运行此段代码后发现很奇怪，虽然我们重写了tryAcquireShared和tryReleaseShared方法，但是SimpleSharedLock依然像一个排它锁，线程既不能同时拥有锁，也不能在释放时同时获取锁。这是因为我们对共享锁的流程以及AQS中state的含义依然不清楚的原因。

4.6 共享锁的原理与流程

首先明白一点：tryAcquireShared方法与tryAcquire方法不同，它返回的不是布尔值，而是整形。返回值为正表明该线程获取了锁，为负表明此线程获取锁失败，应该被阻塞，为0表明该锁尚未被获取。共享锁的加锁流程如下：

与排它锁的lock流程相比，共享锁的流程多了几步，即从setHeadAndPropagate，doReleaseShared和unparkSuccessor。这几步是在当前节点已经被唤醒后，将解锁状态向后传递的过程。本线程将唤醒下一个阻塞的共享线程（被共享锁阻塞的线程），然后此共享线程再唤醒下一个共享线程，这样直至所有共享线程都被唤醒。
共享锁的解锁流程如下：

我们会发现解锁流程并不复杂，且使用的doReleaseShared方法在加锁流程中已经使用过了。
现在我们再来回答，为什么在SimpleSharedLock中，解锁方法没有同时唤醒所有线程？原因就在于，重写的tryAcquireShared方法没有在加锁框架中发挥应有的作用，它在被唤醒后的第一次调用中（也就是在setHeadAndPropagate之前的那一次调用中）重新将state设置为1，也就是锁被获取了。因此下一个被唤醒的线程没有能够通过tryAcquireShared的检测从而重新被阻塞。若要弄清所有细节，你必须阅读AQS的源代码。
至此我们明白了，对state的查询和操作是设计一种共享锁的关键。

4.7 一次唤醒所有阻塞线程的共享锁

假设有这样一种共享锁，它天生就阻塞所有调用lock的线程，但一旦有其他线程调用unlock，则唤醒所有线程，那么应该这样设计：

public class SimpleSharedLock2 {    private static class Sync extends AbstractQueuedSynchronizer {        @Override        protected int tryAcquireShared(int arg) {            return getState() == 0 ? 1 : -1;        }        @Override        protected boolean tryReleaseShared(int arg) {            for (; ; ) {                if (compareAndSetState(1, 0)) {                    return true;                }            }        }        protected Sync() {            setState(1);        }    }    private final Sync sync = new Sync();    public void lock() {        sync.acquireShared(1);    }    public void unlock() {        sync.releaseShared(1);    }    private static class MyThread extends Thread {        private final String name;        private final SimpleSharedLock2 lock;        private MyThread(String name, SimpleSharedLock2 lock) {            this.name = name;            this.lock = lock;        }        @Override        public void run() {            try {                System.out.println(name + " begin to get lock");                lock.lock();                System.out.println(name + " get the lock");                TimeUnit.SECONDS.sleep(2);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    public static void main(String[] args) {        final SimpleSharedLock2 lock = new SimpleSharedLock2();        MyThread t1 = new MyThread("t1", lock);        MyThread t2 = new MyThread("t2", lock);        MyThread t3 = new MyThread("t3", lock);        t1.start();        t2.start();        t3.start();        try {            TimeUnit.SECONDS.sleep(5);            System.out.println("main thread invoke unlock ");            lock.unlock();            t1.join();            t2.join();            t3.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("main thread exit!");    }}

运行此代码，我们会发现，这种共享锁果然符合设计。但是，它是一种一次性的锁，用完之后，由于tryReleaseShared不能将state的值重新设置为其他值，因此以后该锁就失效了。这个锁其实就是简化版的CountDownLatch，我会在后续文章中详细介绍它的使用。

4.8 拥有多个许可证的共享锁

SimpleSharedLock2能够一次释放多个阻塞线程，现在我们设计一种共享锁，它允许n个线程同时获取锁，就仿佛该锁有n个许可证，每个许可证允许一个线程获取锁。释放时，每个线程会还回一个许可证让后续的线程竞争。

public class SimpleSharedLock3 {    private static class Sync extends AbstractQueuedSynchronizer {        final int getPermits() {            return getState();        }        @Override        protected int tryAcquireShared(int arg) {            for (; ; ) {                int available = getState();                int remaining = available - arg;                if (remaining < 0 ||                        compareAndSetState(available, remaining))                    return remaining;            }        }        @Override        protected boolean tryReleaseShared(int arg) {            for (; ; ) {                int available = getState();                int remaining = available + arg;                if (compareAndSetState(available, remaining)) {                    return true;                }            }        }        protected Sync(int permits) {            setState(permits);        }    }    public SimpleSharedLock3(int permits) {        sync = new Sync(permits);    }    private final Sync sync;    public void lock() {        sync.acquireShared(1);    }    public void unlock() {        sync.releaseShared(1);    }    public int getPermits() {        return sync.getPermits();    }    private static class MyThread extends Thread {        private final String name;        private final SimpleSharedLock3 lock;        private MyThread(String name, SimpleSharedLock3 lock) {            this.name = name;            this.lock = lock;        }        @Override        public void run() {            try {                lock.lock();                System.out.println(name + " get the lock, permits = " + lock.getPermits());                TimeUnit.SECONDS.sleep(2);            } catch (InterruptedException e) {                e.printStackTrace();            }        }    }    public static void main(String[] args) {        //给予此锁2个许可        final SimpleSharedLock3 lock = new SimpleSharedLock3(2);        MyThread t1 = new MyThread("t1", lock);        MyThread t2 = new MyThread("t2", lock);        MyThread t3 = new MyThread("t3", lock);        t1.start();        t2.start();        t3.start();        try {            TimeUnit.SECONDS.sleep(5);            lock.unlock();            System.out.println("main thread invoke unlock, permits = " + lock.getPermits());            t1.join();            t2.join();            t3.join();        } catch (InterruptedException e) {            e.printStackTrace();        }        System.out.println("main thread exit!");    }}

运行结果表明，这种锁符合设计，它其实就是一个简化版的Semaphore。

5. 可重入锁ReentrantLock

了解了AQS的原理之后，再来看RentrantLock就非常简单了。从实现原理上来说，它与我们之前设计的SimpleLock很类似。但是作为Java Concurrency包中使用最频繁的锁，它还有可重入性、可中断性、公平策略和Condition等特性。RentrantLock是一个排它锁，因此当一个线程获取锁之后，其他线程只能阻塞。但是若拥有锁的线程重复调用lock方法，依然可以重复进入锁。被RentrantLock阻塞的线程可以被中断，并抛出一个InterruptedException异常。

5.1 RentrantLock

与synchronize关键字相比，ReentrantLock更加灵活，唯一的不足是使用时必须使用try-finally模式来进行加解锁，下面是使用它的一个简单代码：

public class ReentrantLockExam {    public static void main(String[] args) {        final ReentrantLock lock = new ReentrantLock();        ExecutorService service = Executors.newCachedThreadPool();        for (int i = 0; i < 2; i++) {            service.execute(new Runnable() {                @Override                public void run() {                    try {                        System.out.println(Thread.currentThread() + " ready to get lock");                        lock.lock();                        System.out.println(Thread.currentThread()+" get the lock");                        for (int j = 0; j < 5; j++) {                            System.out.println(Thread.currentThread()+" is running, number = "+j);                            TimeUnit.MILLISECONDS.sleep(500);                        }                    } catch (InterruptedException e) {                        e.printStackTrace();                    } finally {                        lock.unlock();                        System.out.println(Thread.currentThread()+" unlock");                    }                }            });        }        service.shutdown();    }}

代码中，两个线程竞争一把RentrantLock锁，得到锁的线程持续运行，直至解锁后，另一个线程才等得到锁并运行。若我们将lock方法连续调用两次，程序依然能够正常运行；将unlock方法也连续调用两次，线程也能够正常解锁。每lock一次，拥有该锁的线程的计数增加1，每unlock一次，计数减少1，当AQS的state为0时，所有线程可以竞争锁。

5.2 Condition

Condition是与RentrantLock配合使用，来实现synchronize中的wait、notify功能的一个接口，其具体实现类为AQS中的ConditionObject。配合使用的方法如下所示（此示例来自JDK文档，本文做了扩充）：

public class ConditionExam {    public static void main(String[] args) {        ExecutorService service = Executors.newCachedThreadPool();        final BoundedBuffer buffer = new BoundedBuffer();        service.execute(new Runnable() {            @Override            public void run() {                try {                    for (int i = 0; i < 1000; i++) {                        String str = "string" + i;                        buffer.put(str);                        System.out.println(Thread.currentThread() + " put " + str);                        TimeUnit.MILLISECONDS.sleep(50);                    }                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        });        service.execute(new Runnable() {            @Override            public void run() {                try {                    for (int i = 0; i < 1000; i++) {                        String str = (String) buffer.take();                        System.out.println(Thread.currentThread() + " take " + str);                        TimeUnit.MILLISECONDS.sleep(50);                    }                } catch (InterruptedException e) {                    e.printStackTrace();                }            }        });        service.shutdown();    }    private static class BoundedBuffer {        final Lock lock = new ReentrantLock();        final Condition notFull = lock.newCondition();        final Condition notEmpty = lock.newCondition();        final Object[] items = new Object[100];        int putptr, takeptr, count;        public void put(Object x) throws InterruptedException {            lock.lock();            try {                while (count == items.length)                    notFull.await();                items[putptr] = x;                if (++putptr == items.length) putptr = 0;                ++count;                notEmpty.signal();            } finally {                lock.unlock();            }        }        public Object take() throws InterruptedException {            lock.lock();            try {                while (count == 0)                    notEmpty.await();                Object x = items[takeptr];                if (++takeptr == items.length) takeptr = 0;                --count;                notFull.signal();                return x;            } finally {                lock.unlock();            }        }    }}

在上面的代码中，使用一个ReentrantLock以及它的两个Condition实现了对一个原生数组的安全并发访问，其中notFull条件用来控制数组不会溢出，notEmpty条件控制数组不会为空时还被取出元素。

6. 读写锁ReentrantWriteReadLock

读写锁ReentrantWriteReadLock的用法比较难以理解，因此用一个大家都熟悉的场景来说明。假设一个班级有一块黑板（共享资源），有多个老师都需要在黑板上书写。老师在写之前，先要获取写锁（writeLock），在写的时候其他的老师和学生都不能在黑板上写或者读，老师写完之后，释放写锁。学生在读黑板之前，先要获取读锁（readLock），多个学生可以同时获取读锁，因此多个学生可以同时读取黑板上的内容，在读的时候其他老师不能在黑板上写，学生读完之后，释放读锁。直至所有学生都释放完读锁，才能够由老师获取写锁。例子代码如下：

public class ReentrantReadWriteLockExam {    public static Random rand = new Random(System.currentTimeMillis());    public static void main(String[] args) {        ReentrantReadWriteLock lock = new ReentrantReadWriteLock();        StringBuilder blackboard = new StringBuilder(100);        ExecutorService service= Executors.newCachedThreadPool();        service.execute(new Teacher(lock, "Chinese Teacher", blackboard));        service.execute(new Teacher(lock, "English Teacher", blackboard));        service.execute(new Student(lock,"Wang",blackboard));        service.execute(new Student(lock,"Li",blackboard));        service.execute(new Student(lock,"Zhang",blackboard));        service.shutdown();    }    private static class Teacher extends Thread {        final private ReentrantReadWriteLock lock;        final private String name;        final private StringBuilder blackboard;        private AtomicInteger id = new AtomicInteger(0);        private Teacher(ReentrantReadWriteLock lock, String name, StringBuilder blackboard) {            this.lock = lock;            this.name = name;            this.blackboard = blackboard;        }        @Override        public void run() {            for (int i = 0; i < 1000; i++) {                try {                    lock.writeLock().lock();                    System.out.println(name + " get write lock");                    blackboard.delete(0, 99).append(name + " has written on the blackboard, number = " + id.getAndIncrement());                    System.out.println(name + " write content:" + blackboard);                    TimeUnit.MILLISECONDS.sleep(rand.nextInt(500));                } catch (InterruptedException e) {                    e.printStackTrace();                } finally {                    lock.writeLock().unlock();                    System.out.println(name + " release write lock");                }            }        }    }    private static class Student extends Thread {        final private ReentrantReadWriteLock lock;        final private String name;        final private StringBuilder blackboard;        private Student(ReentrantReadWriteLock lock, String name, StringBuilder blackboard) {            this.lock = lock;            this.name = name;            this.blackboard = blackboard;        }        @Override        public void run() {            for (int i = 0; i < 1000; i++) {                try {                    lock.readLock().lock();                    System.out.println(name + " get read lock");                    System.out.println(name + " read the blackboard:" + blackboard);                    TimeUnit.MILLISECONDS.sleep(rand.nextInt(500));                } catch (InterruptedException e) {                    e.printStackTrace();                } finally {                    lock.readLock().unlock();                    System.out.println(name+" release the read lock");                }            }        }    }}

总结规则如下：
1.写锁是排它锁，一旦被获取，其他竞争写锁的线程被阻塞，其他竞争读锁的线程也被阻塞；
2.写锁被释放后，其他的线程可以竞争写锁或者读锁；
3.读锁是共享锁，它可以同时被多个线程获取，但是读锁和写锁是不能同时被不同的线程获取的；
4.所有的读锁被释放后，其他的线程可以竞争写锁。

7. 小结

为了提供区别于synchronize关键的阻塞机制，Java提供了锁包。锁包的核心类是AQS，它提供了排它锁和共享锁的流程框架，通过继承此类，可以构造出各种类型的同步器。可重入锁ReentrantLock是使用最广泛的排它锁，除了拥有可重入特性外，它还提供了Condition用来模拟Object的wait和notify操作。读写锁ReentrantWriteReadLock提供了对共享资源的读写保护，可以被方便的用于各类共享资源的访问控制。