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

您好，我是湘王，这是我的博客园，欢迎您来，欢迎您再来～ Java中的AQS（AbstractQueuedSynchronizer，抽象队列同步器）是用来实现锁及其他同步功能组件的Java底层技术基础，java.util.concurrent包下大部分类的实现都离不开它。 通过继承AQS： 1、Ree ...

推荐整理分享Java多线程（6）：锁与AQS（中），希望有所帮助，仅作参考，欢迎阅读内容。

文章相关热门搜索词:,内容如对您有帮助，希望把文章链接给更多的朋友！

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

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 * 方法是通过原子更新来实现同步的 * * <p> * 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这样的方法，通过调用恰当的具体 锁和相关同步器方法，以便实现他们自己的公共方法 * * <p> * This class supports either or both a default <em>exclusive</em> mode and a * <em>shared</em> 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. 仅支持一种模式的子类，不必定义另一种模式下的方法 * * <p> * 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的行为依赖于其同步器实现的语义 * * <p> * 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，将它们导入到类中以实现其同步机制 * * <p> * 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方法来恢复已知的初始状态 * * * <h3>Usage</h3> 使用 * * <p> * 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}: 使用这个类作为同步器锁，需要重新定义以下方法： * * <ul> * <li>{@link #tryAcquire} * <li>{@link #tryRelease} * <li>{@link #tryAcquireShared} * <li>{@link #tryReleaseShared} * <li>{@link #isHeldExclusively} * </ul> * * Each of these methods by default throws * {@link UnsupportedOperationException}. * 这些方法默认抛出UnsupportedOperationException异常 * * Implementations of these methods must be internally thread-safe, and should * in general be short and not block. 这些方法的实现必须在内部是线程安全的，而且通常都很简短，没有阻塞 * * Defining these methods is the <em>only</em> supported means of using this * class. 定义这些方法是使用这个类唯一可行的方式 * * All other methods are declared {@code final} because they cannot be * independently varied. 所有其他的方法都被