AbstractQueuedSynchronizer框架浅析

AbstractQueuedSynchronizer框架浅析

1.概述

AbstractQueuedSynchronizer(AQS)抽象类提供一个实现阻塞锁和依赖于FIFO等待队列的同步器的框架。
AQS被设计用来作为众多同步器的基类，例如ReentrantLock、Semaphore、CountDownLatch、FutureTask以及ReentrantReadWriteLock。AQS依赖于一个整数值，用来代表状态。AQS的子类可以通过覆写protect方法来改变状态，并且定义状态代表具体什么含义。不同的同步器对状态的含义解释不同：

• 在ReentrantLock中，AQS的同步状态用于保存锁获取操作的次数；
• 在FutureTask中，AQS同步状态被用来保存任务的状态；
• 在Semaphore和CountDownLatch中，AQS的同步状态用于保存当前可用许可的数量；

针对AQS中的状态，只可以通过AQS的getState()、setState()和compareAndSetState()方法来改变状态。

同步器类应该使用私有的AQS子类来实现功能，而不应该直接继承AQS类。AQS类没有实现任何同步接口，它只是定义了一些可以被具体同步器和锁调用的方法，例如acquireInterruptibly方法。AQS子类需要自己实现以下方法：

• tryAcquire()
• tryRelease()
• tryAcquireShared()
• tryReleaseShared()
• isHeldExclusively()

这些方法默认会抛出UnsupportedOperationException异常。在这些方法实现中，可以使用getState()、setState()和compareAndSetState()来获取或修改AQS的状态。这些方法的实现必须是线程安全的，并且应该实现简单且没有阻塞。只有这些方法可以被子类覆写，其他的AQS的公开方法都是final方法。

AQS同时支持独占操作模式(例如ReentrantLock)和非独占操作模式(例如Semaphore和CountDownLatch)。当以独占模式获取锁时，只有一个线程能访问成功，其他线程都访问失败；而以非独占模式获取锁时，多个线程可以同时访问成功。不同操作模式的线程都在同一个FIFO队列中等待。通常，AQS的子类只支持一种操作模式(独占或非独占)，但也有同时支持两种操作模式的同步器，例如ReadWriteLock的子类，它的读取锁是非独占操作模式，而写入锁是独占操作模式。

由于在将线程放入FIFO等待队列之前，需要尝试一次acquire，因此有可能新的acquire线程可以获取成功，尽管等待队列中还有其他线程阻塞等待，这是一种非公平策略。然而，可以在tryAcquire()或者tryAcquireShared()方法中禁止线程抢占，具体是通过hasQueuedPredecessors()方法判断等待队列中是否有线程在阻塞等待，如果有线程阻塞等待，则让tryAcquire()或者tryAcquireShared()方法返回false，这样的话，acquire线程会被放入等待队列的尾部，然后唤醒阻塞等待的线程，这是一种公平的策略。

AQS类为同步器的状态、参数的获取和释放，以及内部FIFO等待队列，提供了一个高效的和可扩展的基础。当这些不能满足你的要求时，你可以自定义java.util.concurrent.atomic原子类，自定义java.util.Queue类，以及LockSupport类来提供阻塞支持。

AQS框架的一个类图如下所示：

2.源码分析

2.1 AbstractQueuedSynchronizer类的继承关系

AQS类继承了AbstractOwnableSynchronizer类，实现了Serializable接口。AbstractOwnableSynchronizer类主要是用来保存同步器被哪个线程独占使用。

public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
    ......
}

public abstract class AbstractOwnableSynchronizer
implements java.io.Serializable {

    protected AbstractOwnableSynchronizer() { }

    //The current owner of exclusive mode synchronization.
    private transient Thread exclusiveOwnerThread;

    protected final void setExclusiveOwnerThread(Thread thread) {
        exclusiveOwnerThread = thread;
    }

    protected final Thread getExclusiveOwnerThread() {
        return exclusiveOwnerThread;
    }
}

2.2 Node内部类

在AQS类中，定义了一个FIFO等待队列节点的内部类Node。

static final class Node {
    /** Marker to indicate a node is waiting in shared mode */
    static final Node SHARED = new Node();
    /** Marker to indicate a node is waiting in exclusive mode */
    static final Node EXCLUSIVE = null;

    /** waitStatus value to indicate thread has cancelled */
    static final int CANCELLED =  1;
    /** waitStatus value to indicate successor's thread needs unparking */
    static final int SIGNAL    = -1;
    /** waitStatus value to indicate thread is waiting on condition */
    static final int CONDITION = -2;

    /**
     * waitStatus value to indicate the next acquireShared should
     * unconditionally propagate
     */
    static final int PROPAGATE = -3;

    /*
    * 非负值意味着该节点不需要signal。
    * 该值默认初始化为0,表示普通的同步节点，主要是通过CAS方法来修改该变量值。
    */
    volatile int waitStatus;

    /*
    * 指向前继节点，当前节点需要依赖于前继节点来检查waitStatus。
    * 在入队列的时候赋值，在出队列的时候为null。
    */
    volatile Node prev;

    /*
    * 指向后继节点，当前节点依赖后继节点来唤醒释放
    * 在入队列的时候赋值，在出队列的时候为null。
    */
    volatile Node next;

    /*
    * 将该节点入队列的线程，在构造节点的时候初始化，使用完之后变为null
    */
    volatile Thread thread;

    /*
    * 指向下一个在条件等待，或者是特定的SHARED值的节点。
    * 条件队列只有在获取独占锁时才可以被访问，我们需要一个单链表队列来保存节点，当他们在条件上等待时。
    */
    Node nextWaiter;

     /**
     * Returns true if node is waiting in shared mode.
     */
    final boolean isShared() {
        return nextWaiter == SHARED;
    }

    final Node predecessor() throws NullPointerException {
        Node p = prev;
        if (p == null)
            throw new NullPointerException();
        else
            return p;
    }

    Node() {    // Used to establish initial head or SHARED marker
    }

    Node(Thread thread, Node mode) {     // Used by addWaiter
        this.nextWaiter = mode;
        this.thread = thread;
    }

    Node(Thread thread, int waitStatus) { // Used by Condition
        this.waitStatus = waitStatus;
        this.thread = thread;
    }
}

等待队列是CLH锁队列的变种，CLH锁通常被用来实现自旋锁。在节点中的waitStatus域保存了线程是否需要被阻塞的信息。当一个节点的前继节点被释放了，节点将会收到通知。在等待队列中的每一个节点，都充当着特定通知形式的监控器，并且持有一个等待线程。节点中的waitStatus域并不控制线程是否能获取到锁。如果一个线程是队列中的第一个线程，并不能保证它能竞争成功获取到锁，而只是给予了它参与竞争的权利。

为了将一个Node节点放入到LCH锁队列中，只需要将该Node节点拼接到队列尾部就行；如果为了出队列，则只需设置队列的头指针位置head。

       +------+  prev +-----+       +-----+
  head |      | <---- |     | <---- |     |  tail
       +------+       +-----+       +-----+

插入节点到LCH队列中，只需一个在tail域上的原子操作。相似的，出队列仅仅需要更新head域，但是出队列还需要做一些额外的工作，来决定新的head节点的后继节点是哪个，其中需要考虑的因素有线程是否被取消了，操作是否超时了以及线程是否被中断了。

在Node节点中的prev域主要用来处理节点被取消的情况。如果一个Node节点被取消了，那边它的后继节点需要重新连接到一个未被取消的前继节点。

在Node节点中的next域主要被用来实现阻塞机制。在每个节点中都保存有线程ID，因此当需要唤醒下一个节点时，只需要通过遍历next域，找到后继节点，通过节点获取到线程ID，从而知道该唤醒哪个线程。

等待状态只能取以下几个值：

• SIGNAL：该节点的后继节点当前是阻塞的，因此当前节点在释放和取消之后，必须唤醒它的后继节点。为了避免竞争，acquire方法必须首先进入SIGNAL等着状态，然后再尝试原子获取，这个获取过程可能会失败或者阻塞。
• CANCELLED：该节点由于超时或者中断了被取消了。节点进入了CANCELLED状态之后，就不会再发生状态的变化了。特别地，处于CANCELLED状态节点的线程不会再被阻塞了。
• CONDITION：该节点当前处于一个条件队列中。经过转移之后，该节点将会被作为同步队列的节点使用，此时节点的状态会被设置为0。
• PROPAGATE：releaseShared方法应该传递给其他Node节点。在doReleaseShared方法中，确保传递会继续。