深入理解Java并发编程之Lock和AQS

本文转自个人掘金博客：https://juejin.im/post/5ee37be951882543435a2747

本文主要为《Java并发编程的艺术》第三章的读书记录笔记

Lock接口

Lock vs synchronized

Java SE 5之后，并发包中新增了Lock接口(以及相关实现类)用来实现锁功能，它提供了与synchronized关键字类似的同步功能。但是，它们却有以下不同：

synchronized：使用synchronized的关键字将会隐式地获取和释放锁。同时，使用什么类型的锁(偏向，轻量级锁，重量级锁)以及锁的具体实现都是由JVM底层实现。

Lock接口：Lock接口相关实现类对于锁的获取和释放需要显示进行。同时，怎样获取和释放是由开发者(包括JDK源码)自行决定的。这样的话，它就拥有了锁获取与释放的可操作性、非阻塞地获取锁、可中断的获取锁以及超时获取锁等多种synchronized关键字所不具备的同步特性。

Lock接口API

Lock是一个接口，它定义了锁获取和释放的基本操作，Lock的API如下:

1. void lock()：阻塞获取锁。如果锁获取不到，当前线程就无法进行线程调度只能等待直到获取到锁。
2. void lockInterruptibly() throws InterruptedException：可中断的阻塞获取锁。和lock()方法的不同是该方法在锁的获取中可以中断当前线程。
3. boolean tryLock()：尝试非阻塞地获取锁。调用该方法后立即返回，如果能够获取锁则返回true，否则返回false。
4. boolean tryLock(long time, TimeUnit unit) throws InterruptedException：阻塞超时获取锁。当前线程在以下3种情况会返回：
   • 当前线程在超时时间内获得了锁，返回true
   • 当前线程在超时时间内被中断，抛出异常
   • 超时时间结束，返回false
5. void unlock()：释放锁。在Lock接口的实现类中，通常只有拥有锁的线程才能释放它。
6. Condition newCondition()：返回一个和当前锁绑定Condition对象实例。

Lock接口的实现如ReentrantLock基本都是通过聚合了一个 队列同步器(AQS)的子类来完成线程访问控制的。

AbstractQueuedSynchronizer（AQS）

抽象类AbstractQueuedSynchronizer提供了一个基础框架，它可以用来实现阻塞锁和其他相关的依赖于FIFO等待队列同步组件(比如Semaphore)。它的实现主要依赖于一个单一的原子int变量值state来表示同步状态。继承的子类必须重写AQS的几个protected修饰的用来改变同步状态的方法以及基于这些状态进行锁获取和释放的方法。AQS类里面的其他方法主要实现了排队和阻塞的机制。继承AQS的子类可能会维护一些其他的状态值，但是只能通过getState,setState以compareAndSetState这三个方法来原子地更新管理同步状态的state值。

继承AQS的子类被推荐定义为阻塞锁或者同步组件实现类的静态内部类。AQS自己本身没有实现任何同步接口。相反地，它仅仅是定义了若干同步状态的获取和释放方法来供阻塞锁或者同步组件的使用，来实现子类的公共方法。

AQS既支持独占式获取同步状态，又支持共享式获取同步状态，也支持两者模式具备。默认情况下是独占式获取同步状态。

1. 独占模式指的是一旦有一个线程占有，其他线程便无法占有。
2. 共享模式支持的是多线程占有。

AQS并不关心这些不同模式之间的差异。不同模式下的等待线程共享同一个FIFO队列。通常，AQS的实现子类要么只支持独占模式，要么只支持共享模式。但是，也有例外，比如ReadWriteLock两种都支持。只支持独占模式或者是共享模式的子类不需要定义另一种模式的方法。

AQS是实现锁Lock接口或者是同步组件的关键，在锁的实现中聚合AQS，利用AQS实现锁的语义。可以这样理解二者之间的关系：

1. Lock接口是面向使用者的，它定义了使用者与锁交互的接口（比如可以允许两个线程并行访问），隐藏了实现细节；
2. AQS面向的是锁的实现者，它简化了锁的实现方式，屏蔽了同步状态管理、线程的排队、等待与唤醒等底层操作。锁和AQS很好地隔离了使用者和实现者所需关注的领域。

AQS的接口与实例

AQS的接口

同步器的设计是基于模板模式的，也就是说，使用者需要继承AQS并重写指定的方法，随后将AQS组合在自定义同步组件的实现中，并调用AQS提供的模板方法，而这些模板方法将会调用使用者重写的方法。

重写AQS指定的方法时，需要使用AQS提供的如下3个原子操作方法来访问或修改同步状态:

1. getState()：获取当前同步状态。
2. setState(int newState)：设置当前同步状态。
3. compareAndSetState(int expect,int update)：使用CAS设置当前状态，该方法能够保证状态设置的原子性。

继承AQS必须重写的方法如下所示：

1. protected boolean tryAcquire(int arg)：独占式获取同步状态，实现该方法需要查询当前状态并判断同步状态是否符合预期，然后再进行CAS设置同步状态。
2. protected boolean tryRelease(int arg)：独占式释放同步状态，等待获取同步状态的线程将有机会获取同步锁。
3. protected int tryAcquireShared(int arg)：共享式的获取同步状态，返回大于等于0的值，表示锁获取成功，反之，获取失败。
4. protected boolean tryReleaseShared(int arg)：共享式释放同步状态。
5. protected boolean isHeldExclusively()：当前AQS是否在独占模式下被线程占用，一般该方法表示是否被当前线程所独占。

继承AQS实现自定义同步组件时，将会调用AQS提供的模板方法。这些模板方法如下所示，注意到这些方法都是final修饰，表示这些方法不能被重写。

1. public final void acquire(int arg): 独占式的获取同步状态，如果当前线程获取同步状态成功，则由该方法返回。否则，将会进入同步队列等待，该方法将会调用重写的tryAcquire(int arg)。
2. public final void acquireInterruptibly(int arg): 与acquire(int arg)相同，但是该方法响应中断，当前线程未获取同步状态而进行同步队列中，如果当前线程被中断，则该方法会抛出InterruptedException并返回。
3. public final boolean tryAcquireNanos(int arg, long nanosTimeout) throws InterruptedException：在acquireInterruptibly(int arg)基础上增加了超时限制，如果当前线程在超时时间内没有获取同步状态，那么将会返回false，如果获取到了返回true。
4. public final boolean release(int arg)：独占式的释放同步队列，该方法会在释放同步状态之后，将同步队列中的第一个节点包含的线程唤醒。
5. public final void acquireShared(int arg)：共享式的获取同步状态，如果当前线程未获取到同步状态，将会进入同步队列等待，与独占式获取的主要区别是在同一时刻可以有多少个线程获取到同步状态。
6. public final void acquireSharedInterruptibly(int arg)：与acquireShared(int arg)相同，该方法响应中断。
7. public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException：在acquireSharedInterruptibly(int arg)基础上增加了超时限制。
8. public final boolean releaseShared(int arg)：共享式的释放同步状态。
9. public final Collection getQueuedThreads()：获取等待在同步队列上的线程集合。

同步器提供的模板方法基本上分为3类：独占式获取与释放同步状态、共享式获取与释放同步状态和查询同步队列中的等待线程情况。自定义同步组件将使用同步器提供的模板方法来实现自己的同步语义。

一个简单的继承AQS的独占锁Mutex

独占锁就是在同一时刻只能有一个线程获取到锁，而其他获取锁的线程只能处于同步队列中等待，只有获取锁的线程释放了锁，后继的线程才能够获取锁，如下所示：

class Mutex implements Lock {
    // 仅需要将操作代理到Sync上即可
    private final Sync sync = new Sync();

    public void lock() {
        sync.acquire(1);
    }

    public boolean tryLock() {
        return sync.tryAcquire(1);
    }

    public void unlock() {
        sync.release(1);
    }

    public Condition newCondition() {
        return sync.newCondition();
    }

    public boolean isLocked() {
        return sync.isHeldExclusively();
    }

    public boolean hasQueuedThreads() {
        return sync.hasQueuedThreads();
    }