目录
AbstractQueuedSynchronizer (抽象队列同步器框架)
AbstractQueuedSynchronizer源码分析
带着BAT大厂的面试问题去理解
- 什么是AQS? 为什么它是核心?
- AQS的核心思想是什么? 它是怎么实现的? 底层数据结构等
- AQS有哪些核心的方法?
- AQS定义什么样的资源获取方式?
- AQS定义了两种资源获取方式：
- 独占：(只有一个线程能访问执行，又根据是否按队列的顺序分为公平锁 和非公平锁，如ReentrantLock)
- 共享：(多个线程可同时访问执行，如Semaphore、CountDownLatch、 CyclicBarrier )。ReentrantReadWriteLock可以看成是组合式，允许多个线程同时对某一资源进行读。
- AQS定义了两种资源获取方式：
- AQS底层使用了什么样的设计模式? 模板设计模式
以上锁的定义均是由于AQS锁带来的特性
AbstractQueuedSynchronizer (抽象队列同步器框架)
AQS是一个用来构建锁和同步器的框架，使用AQS能简单且高效地构造出同步器，比如我们提到的ReentrantLock，Semaphore，SynchronousQueue，FutureTask等等皆是基于AQS的。
当然，我们自己也能利用AQS非常轻松容易地构造出符合我们自己需求的同步器；
Java并发编程核心在于java.concurrent.util包。
而JUC当中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，
而这个行为的抽象就是基于AbstractQueuedSynchronizer简称AQS，AQS定义了一套多线程访问共享资源的同步器框架，是一个依赖状态(state)的同步器。
AQS规定了同步器应当具备的一些基本特性：比如等待队列、条件队列、独占获取、共享获取等
AQS具备的基本特性
• 阻塞等待队列 通过CLH 队列 和 条件队列 实现
• 共享/独占 通过 AbstractOwnableSynchronizer 设置线程独占
• 公平/非公平 通过CLH 队列 的实现，根据在获取锁时是否需要根据入队顺序进行获取
• 可重入 通过AbstractQueuedSynchronizer 的state状态值进行实现
• 允许中断
AQS 实现分析
AQS 核心思想（重点）
如果被请求的共享资源空闲，则将当前请求资源的线程设置为有效的工作线程，并且将共享资源设置为锁定状态。
如果被请求的共享资源被占用，那么就需要一套 线程阻塞等待以及被唤醒时锁分配 的机制（这个机制AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中）
CLH队列是一个虚拟的双向队列(虚拟的双向队列即不存在队列实例，仅存在结点之间的关联关系)。 同步等待队列 AQS是将每条请求共享资源的线程封装成一个 CLH队列的一个结点(Node) 来实现锁的分配。也就是说Node是thread 线程的一种包装类！1. AQS内部维护属性
AQS使用一个成员变量state来表示同步状态（作用：记录上锁次数，用于实现可重入） ，通过内置的FIFO队列来完成获取资源线程的排队工作。
并且AQS使用CAS对该同步状态进行原子操作实现对其值的修改。
并通过getState，setState，compareAndSetState等方法维护同步状态state
private volatile int state;//共享变量，使用volatile修饰保证线程可见性
protected final int getState() { //返回同步状态的当前值
return state;
}
protected final void setState(int newState) {// 设置同步状态的值
state = newState;
}
// 原子地(CAS操作)将同步状态值设置为给定值update如果当前同步状态的值等于expect(期望值)
protected final boolean compareAndSetState(int expect, int update) {
// unsafe.compareAndSwapInt()方法通过汇编指令Atomic::cmpxchg 来实现比较和替换操作
return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
}2.AQS两种资源共享方式
•Exclusive-独占，只有一个线程能执行，如ReentrantLock
又根据是否按队列的顺序进行入队分为：
公平锁 和 非公平锁
•Share-共享，多个线程可以同时执行，如Semaphore/CountDownLatch
什么是共享模式 什么是独占模式？
Node类中有两个常量 SHARE和 EXCLUSIVE，顾名思义这两个常量用于表示这个结点支持共享模式还是独占模式，
- 共享模式指: 允许多个线程获取同一个锁而且可能获取成功，
- 独占模式指: 一个锁如果被一个线程持有，其他线程必须等待。
多个线程读取一个文件可以采用共享模式
而当有一个线程在写文件时不会允许另一个线程写这个文件，这就是独占模式的应用场景。
3.AQS定义两种队列
- 同步等待队列 基于双向链表实现 通过内置的FIFO队列来完成获取资源线程的排队工作，（也就是CLH 队列）
- 条件等待队列 基于单向链表实现
AQS中有两种队列，一是同步队列，二是条件队列,两种队列都是使用 Node类 作为节点
Sync queue（也就是CLH 队列) : 即同步队列，是双向链表，包括head结点和tail结点，head结点主要用作后续的调度。
Condition queue(条件队列) : 不是必须的，其是一个单向链表，只有当使用Condition时，才会存在此单向链表，并且可能会有多个Condition queue。
详细解析上面两种队列的构建方法
Sync queue同步队列：
通过Node 中的前驱结点 prev 和 后继结点 next; 形成双向链表结构
CLH队列是一种基于双向链表数据结构的队列，是FIFO先入先出线程等待队列，Java中的CLH队列是原CLH队列的一个变种,线程由原自旋机制改为阻塞机制。
条件队列：
通过nextWaiter指向下一个节点 构成单向链表实现条件队列
Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,
只有当该条件具备时，这些等待线程才会被唤醒，从而重新争夺锁。
AbstractQueuedSynchronizer源码分析
类的继承关系
AbstractQueuedSynchronize通过继承 AbstractOwnableSynchronizer 来完成线程资源获取方式的设置（该类用于设置独占线程）
public abstract class AbstractOwnableSynchronizer implements java.io.Serializable {
protected AbstractOwnableSynchronizer() { }
// 当前线程为独占模式同步器
private transient Thread exclusiveOwnerThread;
// 设置独占线程
protected final void setExclusiveOwnerThread(Thread thread) {
exclusiveOwnerThread = thread;
}
// 获取独占线程
protected final Thread getExclusiveOwnerThread() {
return exclusiveOwnerThread;
}
} AQS内部类
AbstractQueuedSynchronizer类有两个内部类，分别为Node类与ConditionObject类
1.类的内部类 -Node类
每个线程被阻塞的线程都会被封装成一个Node结点，放入队列。每个节点包含了一个Thread类型的引用，并且每个节点都存在一个状态 waitState。
Node类内部通过属性 SHARED EXCLUSIVE 声明等待线程的同步资源访问模式，分为共享与独占
Node类内部通过属性 waitState (32位) 来维护线程所处的等待状态，同时声明了五种信号量代表waitState ，如源代码所示
Node类内部通过属性 prev next 来构建出 CLH 队列，维护线程之间的入队顺序
Node类内部通过属性 thread nextWaiter 来维护条件队列中Node，并通过 nextWaiter 存储条件队列中的节点顺序
static final class Node {
// 声明等待线程的同步资源访问模式，分为共享与独占
static final Node SHARED = new Node();
// 共享模式
static final Node EXCLUSIVE = null; // 独占模式
// 场景：当该线程等待超时或者被中断，需要从同步队列中取消等待，则该线程被置1，即被取消（这里该线程在取消之前是等待状态）。节点进入了取消状态则不再变化；
static final int CANCELLED = 1;
// 场景：后继的节点处于等待状态，当前节点的线程如果释放了同步状态或者被取消（当前节点状态置为-1），将会通知后继节点，使后继节点的线程得以运行；
static final int SIGNAL = -1;
// 条件队列：Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,只有当该条件具备时 ，这些等待线程才会被唤醒，从而重新争夺锁
// 场景：节点处于条件等待队列中，节点线程等待在Condition上，当其他线程对Condition调用了signal()方法后，该节点从条件等待队列中转移到同步队列中，加入到对同步状态的获取中
static final int CONDITION = -2;
// 场景：表示下一次的共享状态会被无条件的传播下去；
static final int PROPAGATE = -3;
volatile int waitStatus;
// waitStatus 用于记录线程状态
volatile Node prev;
// 前驱结点
volatile Node next;
// 后继结点
volatile Thread thread;
// 与该结点绑定的线程
Node nextWaiter;
// 存储condition队列中的后继节点
final boolean isShared() { // 是否为共享模式
return nextWaiter == SHARED;
}
final Node predecessor() throwsNullPointerException { // 获取前驱结点
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
Node() { }
// Used to establish initial heador SHARED marker
Node(Thread thread, Node mode) { // Used byaddWaiter
this.nextWaiter = mode;
this.thread = thread;
}
Node(Thread thread, int waitStatus) { //Used by Condition
this.waitStatus = waitStatus;
this.thread = thread;
}
}2.类的内部类 - ConditionObject类
维护条件队列的 入队 出队 和 阻塞 唤醒等待线程的一些列操作
public class ConditionObject implements Condition, java.io.Serializable {
// 版本号
private static final long serialVersionUID = 1173984872572414699L;
// condition队列的头结点
private transient Node firstWaiter;
// condition队列的尾结点
private transient Node lastWaiter;
public ConditionObject() { }
// 添加新的waiter到wait队列
private Node addConditionWaiter() {
Node t = lastWaiter;
// 保存尾结点
if ( t != null && t.waitStatus != Node.CONDITION) { // 尾结点不为空，并且尾结点的状态不为CONDITION
unlinkCancelledWaiters(); // 清除状态为CONDITION的结点
t = lastWaiter; // 将最后一个结点重新赋值给t
}
Node node = new Node(Thread.currentThread(), Node.CONDITION); // 新建一个结点
if (t == null) // 尾结点为空
firstWaiter = node; // 设置condition队列的头结点
else // 尾结点不为空
t.nextWaiter = node; // 设置为节点的nextWaiter域为node结点
lastWaiter = node; // 更新condition队列的尾结点
return node;
}
// 唤醒头节点，从条件队列到等待队列中
private void doSignal(Node first) {
do { // 循环
if ( (firstWaiter = first.nextWaiter) == null) // 该节点的nextWaiter为空
lastWaiter = null; // 设置尾结点为空
first.nextWaiter = null; // 设置first结点的nextWaiter域
} while (!transferForSignal(first) &&
(first = firstWaiter) != null); // 将结点从condition队列转移到sync队列失败并且condition队列中的头结点不为空，一直循环
}
// 唤醒所有条件队列中的节点，从条件队列到等待队列中
private void doSignalAll(Node first) {
lastWaiter = firstWaiter = null;// condition队列的头结点尾结点都设置为空
do {
// 循环
Node next = first.nextWaiter;// 获取first结点的nextWaiter域结点
first.nextWaiter = null; // 设置first结点的nextWaiter域为空
transferForSignal(first); // 将first结点从condition队列转移到sync队列
first = next;// 重新设置first
} while (first != null);
}
// 从condition队列中清除状态为CANCEL的结点
private void unlinkCancelledWaiters() {
Node t = firstWaiter; // 保存condition队列头结点
Node trail = null;
while (t != null) { // t不为空
Node next = t.nextWaiter; // 下一个结点
if (t.waitStatus != Node.CONDITION) { // t结点的状态不为CONDTION状态
t.nextWaiter = null; // 设置t节点的额nextWaiter域为空
if (trail == null) // trail为空
firstWaiter = next; // 重新设置condition队列的头结点
else // trail不为空
trail.nextWaiter = next; // 设置trail结点的nextWaiter域为next结点
if (next == null) // next结点为空
lastWaiter = trail;// 设置condition队列的尾结点
}
else // t结点的状态为CONDTION状态
trail = t; // 设置trail结点
t = next; // 设置t结点
}
}
// 唤醒一个等待线程。如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁。
public final void signal() {
if (!isHeldExclusively()) // 不被当前线程独占，抛出异常
throw new IllegalMonitorStateException();
Node first = firstWaiter;// 保存condition队列头结点
if (first != null) // 头结点不为空
doSignal(first);// 唤醒一个等待线程
}
// 唤醒所有等待线程。如果所有的线程都在等待此条件，则唤醒所有线程。在从 await 返回之前，每个线程都必须重新获取锁。
public final void signalAll() {
if (!isHeldExclusively()) // 不被当前线程独占，抛出异常
throw new IllegalMonitorStateException();
Node first = firstWaiter; // 保存condition队列头结点
if (first != null) // 头结点不为空
doSignalAll(first);// 唤醒所有等待线程
}
// 等待，当前线程在接到信号之前一直处于等待状态，不响应中断
public final void awaitUninterruptibly() {
Node node = addConditionWaiter(); // 添加一个结点到等待队列
int savedState = fullyRelease(node);// 获取释放的状态
boolean interrupted = false;
while (!isOnSyncQueue(node)) { //
LockSupport.park(this); // 阻塞当前线程
if (Thread.interrupted()) // 当前线程被中断
interrupted = true; // 设置interrupted状态
}
if (acquireQueued(node, savedState) || interrupted) //
selfInterrupt();
}
/** Mode meaning to reinterrupt on exit from wait */
private static final int REINTERRUPT = 1;
/** Mode meaning to throw InterruptedException on exit from wait */
private static final int THROW_IE = -1;
private int checkInterruptWhileWaiting(Node node) {
return Thread.interrupted() ?
(transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) :
0;
}
private void reportInterruptAfterWait(int interruptMode)
throws InterruptedException {
if (interruptMode == THROW_IE)
throw new InterruptedException();
else if (interruptMode == REINTERRUPT)
selfInterrupt();
}
// 等待，当前线程在接到信号或被中断之前一直处于等待状态
public final void await() throws InterruptedException {
if (Thread.interrupted()) // 当前线程被中断，抛出异常
throw new InterruptedException();
Node node = addConditionWaiter(); // 在wait队列上添加一个结点
int savedState = fullyRelease(node);
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
LockSupport.park(this); // 阻塞当前线程
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0) // 检查结点等待时的中断类型
break;
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
// 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态
public final long awaitNanos(long nanosTimeout)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
final long deadline = System.nanoTime() + nanosTimeout;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
transferAfterCancelledWait(node);
break;
}
if (nanosTimeout >= spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return deadline - System.nanoTime();
}
// 等待，当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态
public final boolean awaitUntil(Date deadline)
throws InterruptedException {
long abstime = deadline.getTime();
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (System.currentTimeMillis() > abstime) {
timedout = transferAfterCancelledWait(node);
break;
}
LockSupport.parkUntil(this, abstime);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return !timedout;
}
// 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。此方法在行为上等效于: awaitNanos(unit.toNanos(time)) > 0
public final boolean await(long time, TimeUnit unit)
throws InterruptedException {
long nanosTimeout = unit.toNanos(time);
if (Thread.interrupted())
throw new InterruptedException();
Node node = addConditionWaiter();
int savedState = fullyRelease(node);
final long deadline = System.nanoTime() + nanosTimeout;
boolean timedout = false;
int interruptMode = 0;
while (!isOnSyncQueue(node)) {
if (nanosTimeout <= 0L) {
timedout = transferAfterCancelledWait(node);
break;
}
if (nanosTimeout >= spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
nanosTimeout = deadline - System.nanoTime();
}
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
if (node.nextWaiter != null)
unlinkCancelledWaiters();
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
return !timedout;
}
final boolean isOwnedBy(AbstractQueuedSynchronizer sync) {
return sync == AbstractQueuedSynchronizer.this;
}
// 查询是否有正在等待此条件的任何线程
protected final boolean hasWaiters() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
if (w.waitStatus == Node.CONDITION)
return true;
}
return false;
}
// 返回正在等待此条件的线程数估计值
protected final int getWaitQueueLength() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
int n = 0;
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
if (w.waitStatus == Node.CONDITION)
++n;
}
return n;
}
// 返回包含那些可能正在等待此条件的线程集合
protected final Collection<Thread> getWaitingThreads() {
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
ArrayList<Thread> list = new ArrayList<Thread>();
for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
if (w.waitStatus == Node.CONDITION) {
Thread t = w.thread;
if (t != null)
list.add(t);
}
}
return list;
}
}
从源码中发现 ConditionObject implements Condition ，浅浅的分析下Condition 接口
Condition接口中定义了await、signal方法，用来等待条件、释放条件。之后会详细分析CondtionObject的源码。
public interface Condition {
// 等待，当前线程在接到信号或被中断之前一直处于等待状态
void await() throws InterruptedException;
// 等待，当前线程在接到信号之前一直处于等待状态，不响应中断
void awaitUninterruptibly();
//等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态
long awaitNanos(long nanosTimeout) throws InterruptedException;
// 等待，当前线程在接到信号、被中断或到达指定等待时间之前一直处于等待状态。此方法在行为上等效于: awaitNanos(unit.toNanos(time)) > 0
boolean await(long time, TimeUnit unit) throws InterruptedException;
// 等待，当前线程在接到信号、被中断或到达指定最后期限之前一直处于等待状态
boolean awaitUntil(Date deadline) throws InterruptedException;
// 唤醒一个等待线程。如果所有的线程都在等待此条件，则选择其中的一个唤醒。在从 await 返回之前，该线程必须重新获取锁。
void signal();
// 唤醒所有等待线程。如果所有的线程都在等待此条件，则唤醒所有线程。在从 await 返回之前，每个线程都必须重新获取锁。
void signalAll();
}AQS类的属性
public abstract class AbstractQueuedSynchronizer extends AbstractOwnableSynchronizer implements java.io.Serializable {
private static final long serialVersionUID = 7373984972572414691L; // 版本号
private transient volatile Node head; // 头节点
private transient volatile Node tail; // 尾结点
private volatile int state; // 状态 用于实现可重入锁
static final long spinForTimeoutThreshold = 1000L; // 自旋时间
private static final Unsafe unsafe = Unsafe.getUnsafe(); // Unsafe类实例，底层实现，通过Unsafe 类完成ASC 操作
// 通过内存偏移地址可以找到对应的值
private static final long stateOffset; // state内存偏移地址
private static final long headOffset; // head内存偏移地址
private static final long tailOffset; // tail内存偏移地址
private static final long waitStatusOffset;// waitStatus内存偏移地址
private static final long nextOffset; // next内存偏移地址
static { // 静态初始化块 ,通过unsafe.objectFieldOffset()获取以上变量的内存偏移地址
try {
stateOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("state"));
headOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("head"));
tailOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer.class.getDeclaredField("tail"));
waitStatusOffset = unsafe.objectFieldOffset(Node.class.getDeclaredField("waitStatus"));
nextOffset = unsafe.objectFieldOffset(Node.class.getDeclaredField("next"));
} catch (Exception ex) { throw new Error(ex); }
}
}AQS类的构造方法
此类构造方法为从抽象构造方法，供子类调用。
protected AbstractQueuedSynchronizer() { } AQS类的核心方法：
浅析两个独占模式下的方法：
AQS类的核心方法 -acquire方法
：该方法以独占模式获取(资源)，忽略中断，即线程在aquire过程中，中断此线程是无效的。源码如下:
public final void acquire(int arg) {
if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
} 流程分析：
- 首先调用tryAcquire方法，调用此方法的线程会试图在独占模式下获取对象状态。 此方法应该查询是否允许它在独占模式下获取对象状态，如果允许，则获取它。在AbstractQueuedSynchronize源码中默认会抛出一个异常，即需要子类去重写此方法完成自己的逻辑。之后会进行分析。
- 若tryAcquire失败，则调用addWaiter方法，addWaiter方法完成的功能是将调用此方法的线程封装成为一个结点并放入Sync queue。
- 调用acquireQueued方法，此方法完成的功能是Sync queue中的结点不断尝试获取资源，若成功，则返回true，否则，返回false。
- 由于tryAcquire默认实现是抛出异常，所以此时，不进行分析，之后会结合一个例子进行分析。
首先分析addWaiter方法
addWaiter方法使用快速添加的方式往sync queue尾部添加结点，如果sync queue队列还没有初始化，则会使用enq插入队列中，enq方法源码如下
// 添加等待者
private Node addWaiter(Node mode) {
// 新生成一个结点，默认为独占模式
Node node = new Node(Thread.currentThread(), mode);
// 保存尾结点
Node pred = tail;
if (pred != null) { // 尾结点不为空，即已经被初始化
node.prev = pred; // 将node结点的prev域连接到尾结点
if (compareAndSetTail(pred, node)) { // 比较pred是否为尾结点，是则将尾结点设置为node
pred.next = node; // 设置尾结点的next域为node
return node; // 返回新生成的结点
}
}
enq(node); // 尾结点为空(即还没有被初始化过)，或者是compareAndSetTail操作失败，则入队列
return node;
}
// addWaiter方法使用快速添加的方式往sync queue尾部添加结点，如果sync queue队列还没有初始化，则会使用enq插入队列中，enq方法源码如下
private Node enq(final Node node) {
for (;;) { // 无限循环，确保结点能够成功入队列
// 保存尾结点
Node t = tail;
if (t == null) { // 尾结点为空，即还没被初始化
if (compareAndSetHead(new Node())) // 头节点为空，并设置头节点为新生成的结点
tail = head; // 头节点与尾结点都指向同一个新生结点
} else { // 尾结点不为空，即已经被初始化过
// 将node结点的prev域连接到尾结点
node.prev = t;
if (compareAndSetTail(t, node)) { // 比较结点t是否为尾结点，若是则将尾结点设置为node
// 设置尾结点的next域为node
t.next = node;
return t; // 返回尾结点
}
}
}
}
现在，分析acquireQueue方法。其源码如下:
acquireQueued方法的整个的逻辑,逻辑如下:
- 判断结点的前驱是否为head并且是否成功获取(资源)。
- 若步骤1均满足，则设置结点为head，之后会判断是否finally模块，然后返回。
- 若步骤2不满足，则判断是否需要park当前线程，是否需要park当前线程的逻辑是判断结点的前驱结点的状态是否为SIGNAL，若是，则park当前结点，否则，不进行park操作。
- 若park了当前线程，之后某个线程对本线程unpark后，并且本线程也获得机会运行。那么，将会继续进行步骤①的判断。
// sync队列中的结点在独占且忽略中断的模式下获取(资源)
final boolean acquireQueued(final Node node, int arg) {
// 标志
boolean failed = true;
try {
// 中断标志
boolean interrupted = false;
for (;;) { // 无限循环
// 获取node节点的前驱结点
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) { // 前驱为头节点并且成功获得锁
setHead(node); // 设置头节点
p.next = null; // help GC
failed = false; // 设置标志
return interrupted;
}
// shouldParkAfterFailedAcquire 当获取(资源)失败后，检查并且更新结点状态
// parkAndCheckInterrupt 进行park操作并且返回该线程是否被中断
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
AQS类的核心方法 - release方法
以独占模式释放对象，其源码如下:
tryRelease的默认实现是抛出异常，需要具体的子类实现，如果tryRelease成功，那么如果头节点不为空并且头节点的状态不为0，则释放头节点的后继结点，
unparkSuccessor方法:释放头节点的后继结点
public final boolean release(int arg) {
if (tryRelease(arg)) { // 释放成功
// 保存头节点
Node h = head;
if (h != null && h.waitStatus != 0) // 头节点不为空并且头节点状态不为0
unparkSuccessor(h); //释放头节点的后继结点
return true;
}
return false;
}对于其他方法我们也可以分析，与前面分析的方法大同小异，所以，不再累赘。
AQS类的模板方法API （AQS使用模板方法模式）
同步器的设计是基于模板方法模式的，如果需要自定义同步器一般的方式是这样：
使用者继承AbstractQueuedSynchronizer并重写指定的方法。模板方法模式请参看：设计模式行为型 - 模板方法(Template Method)详解
自定义同步器时需要重写下面几个AQS提供的模板方法：
protected boolean isHeldExclusively() {//该线程是否正在独占资源。只有用到condition才需要去实现它。
throw new UnsupportedOperationException();
}
protected boolean tryAcquire(int arg) { //独占方式。尝试获取资源，成功则返回true，失败则返回false。
throw new UnsupportedOperationException();
}
protected boolean tryRelease(int arg) { //独占方式。尝试释放资源，成功则返回true，失败则返回false。
throw new UnsupportedOperationException();
}
protected int tryAcquireShared(int arg) {//共享方式。尝试获取资源。负数表示失败；0表示成功，但没有剩余可用资源；正数表示成功，且有剩余资源。
throw new UnsupportedOperationException();
}
protected boolean tryReleaseShared(int arg) {//共享方式。尝试释放资源，成功则返回true，失败则返回false。
throw new UnsupportedOperationException();
}
默认情况下，每个方法都抛出 UnsupportedOperationException。 这些方法的实现必须是内部线程安全的，并且通常应该简短而不是阻塞。
AQS类中的其他方法都是final ，所以无法被其他类使用，只有这几个方法可以被其他类使用。
补充内容：
公平锁 和 非公平锁
可重入 和 非可重入锁
读写锁
AQS 如何实现公平和非公平锁（针对于在获取锁失败之后，线程是否能够按照等待获取锁的顺序进行锁的获取）
上面提到：AQS是用CLH队列锁实现的，即将暂时获取不到锁的线程加入到队列中 (同步等待队列)
AQS是将每条请求共享资源的线程 封装成一个CLH锁队列的一个结点(Node) 来实现锁的分配。也就是说Node是thread 线程的一种包装类！
关于AQS 可以参考：
扫一扫
984
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
