Java多线程（6）：锁与AQS（中）

您好，我是湘王，这是我的CSDN博客，欢迎您来，欢迎您再来～

Java中的AQS（AbstractQueuedSynchronizer，抽象队列同步器）是用来实现锁及其他同步功能组件的Java底层技术基础，java.util.concurrent包下大部分类的实现都离不开它。

通过继承AQS：

1、ReentrantLock的内部类实现了公平锁和非公平锁；

2、CountDownLatch的内部类实现了发令枪；

3、ReentrantReadWriteLock的内部类实现了独享锁和共享锁；

4、Semaphore的内部类实现了公平锁和非公平锁。

AQS主要实现两大功能：独占（Exclusive，有时也叫排他）和共享（Share）。

AQS在内部维护一个FIFO（First In First Out，先进先出）的CLH（Craig，Landin，and Hagersten）线程阻塞队列和一个资源同步状态的变量volatile int state。

CLH是一个虚拟的双向队列，也就是不存在队列实例，仅存在节点之间的关联关系的队列。AQS是将每一条请求共享资源的线程，封装成一个CLH线程队列节点（Node），从而实现锁的分配。因此，说了一大堆，用一句简单的话来形容AQS就是：基于CLH线程阻塞队列，通过volatile变量 + CAS + 自旋方式来改变线程状态，成功则获取锁，失败则进入CLH队列。

AQS已经实现了CLH线程阻塞队列的维护，所以一般子类自定义实现AQS，要么是独占，要么是共享，也就是要么实现tryAcquire()和tryRelease()等系列方法，要么实现tryAcquireShared()和tryReleaseShared()等系列方法。

CLH队列由多个node节点组成，而且大量使用“CAS自旋volatile变量”这种经典代码：

 

CLH队列的结构为：

 

给CLH设置首节点：

 

给CLH设置尾节点：

 

整个AQS的流程如图：

 

AQS特别复杂，如果想把多线程搞透的，就需要深入研究每个方法的流程，拿acquire(int)方法的执行流程为例：

 

我把AQS的源码做了较为详细的注释，可以结合注释看看：

/**
 * Provides a framework for implementing blocking locks and related
 * synchronizers (semaphores, events, etc) that rely on first-in-first-out
 * (FIFO) wait queues. 提供了一个实现阻塞锁和依赖FIFO的等待队列的相关的同步器（信号灯、事件等）框架
 * 
 * This class is designed to be a useful basis for most kinds of synchronizers
 * that rely on a single atomic {@code int} value to represent state.
 * 这个类对于大多数使用一个单独原子类的int值来表示状态的同步器很有用
 * 
 * Subclasses must define the protected methods that change this state, and
 * which define what that state means in terms of this object being acquired or
 * released. 子类必须定义protected方法来改变这个状态值，并且定义状态值是获取还是释放对象
 * 
 * Given these, the other methods in this class carry out all queuing and
 * blocking mechanics. 鉴于此，这个类中的其他方法实现了所有排队和阻塞的机制
 * 
 * Subclasses can maintain other state fields, but only the atomically updated
 * {@code int} value manipulated using methods {@link #getState},
 * {@link #setState} and {@link #compareAndSetState} is tracked with respect to
 * synchronization. 子类可以维护其他的状态值字段，但只有getState、setState和compareAndSetState
 * 方法是通过原子更新来实现同步的
 * 
 * 
 * Subclasses should be defined as non-public internal helper classes that are
 * used to implement the synchronization properties of their enclosing class.
 * 子类应该定义成非public的内部helper工具类，用于实现其封闭类的同步属性
 * 
 * Class {@code AbstractQueuedSynchronizer} does not implement any
 * synchronization interface. AbstractQueuedSynchronizer类没有实现任何同步接口
 * 
 * Instead it defines methods such as {@link #acquireInterruptibly} that can be
 * invoked as appropriate by concrete locks and related synchronizers to
 * implement their public methods.
 * 取而代之的是，它定义了像acquireInterruptibly这样的方法，通过调用恰当的具体 锁和相关同步器方法，以便实现他们自己的公共方法
 * 
 * 
 * This class supports either or both a default exclusive mode and a
 * shared mode. 这个类既支持默认的独占模式，也支持共享模式，也支持两种模式一起实现
 * 
 * When acquired in exclusive mode, attempted acquires by other threads cannot
 * succeed. 当在独占模式获取到锁时，其他线程再尝试获取锁会失败
 * 
 * Shared mode acquires by multiple threads may (but need not) succeed.
 * 共享模式，多个线程都能成功获取到锁
 * 
 * This class does not understand these differences except in the mechanical
 * sense that when a shared mode acquire succeeds, the next waiting thread (if
 * one exists) must also determine whether it can acquire as well.
 * 这个类不会理解机制的不同，共享模式中的一个线程获取锁成功了，下一个线程 （如果存在）仍然会去确定它自己是否也可以获取
 * 
 * Threads waiting in the different modes share the same FIFO queue.
 * 线程虽在不同的模式中，却都在等待共享相同的FIFO队列
 * 
 * Usually, implementation subclasses support only one of these modes, but both
 * can come into play for example in a {@link ReadWriteLock}.
 * 通常，子类只需要实现这两种模式中的一种，但也能两种都实现，例如ReadWriteLock
 * 
 * Subclasses that support only exclusive or only shared modes need not define
 * the methods supporting the unused mode. 仅支持一种模式的子类，不必定义另一种模式下的方法
 * 
 * 
 * This class defines a nested {@link ConditionObject} class that can be used as
 * a {@link Condition} implementation by subclasses supporting exclusive mode
 * for which method {@link#isHeldExclusively} reports whether synchronization is
 * exclusively held with respect to the current thread, method {@link #release}
 * invoked with the current {@link #getState} value fully releases this object,
 * and {@link #acquire}, given this saved state value, eventually restores this
 * object to its previous acquired state.
 * 这个类定义了一个嵌套的ConditionObject类，该类可以被支持独占模式的子类用作
 * Condition实现，为此，isHeldExclusively()报告当前线程是否持续保持同步，
 * release方法通过调用getState来完全释放当前对象，并且将当前的资源状态 再保存到state中，最后会将此对象恢复为先前的获取状态
 * 
 * No {@code AbstractQueuedSynchronizer} method otherwise creates such a
 * condition, so if this constraint cannot be met, do not use it.
 * 没有AbstractQueuedSynchronizer方法去创建condition，因此如果不能满足 这个约束，就不要使用它
 * 
 * The behavior of {@link ConditionObject} depends of course on the semantics of
 * its synchronizer implementation. ConditionObject的行为依赖于其同步器实现的语义
 * 
 * 
 * This class provides inspection, instrumentation, and monitoring methods for
 * the internal queue, as well as similar methods for condition objects.
 * 这个类提供检查、追踪和监控内部队列的方法，类似于condition对象的方法
 * 
 * These can be exported as desired into classes using an
 * {@code AbstractQueuedSynchronizer} for their synchronization mechanics.
 * 可以根据需要使用AbstractQueuedSynchronizer，将它们导入到类中以实现其同步机制
 * 
 * 
 * Serialization of this class stores only the underlying atomic integer
 * maintaining state, so deserialized objects have empty thread queues.
 * 这个类仅序列化state的原子值，因此反序列化出来的对象中的线程队列是空的
 * 
 * Typical subclasses requiring serializability will define a {@code readObject}
 * method that restores this to a known initial state upon deserialization.
 * 需要序列化的子类可以在反序列化的时候定义一个readObject方法来恢复已知的初始状态
 * 
 * 
 * 
Usage
 使用
 * 
 * 
 * To use this class as the basis of a synchronizer, redefine the following
 * methods, as applicable, by inspecting and/or modifying the synchronization
 * state using {@link #getState}, {@link #setState} and/or
 * {@link #compareAndSetState}: 使用这个类作为同步器锁，需要重新定义以下方法：
 * 
 * 
 * 
{@link #tryAcquire}