章节概览、
1、回顾
上一章节，我们分析了ReentrantLock的源码：
2、AQS 队列同步器概述
本章节我们深入分析下AQS（AbstractQueuedSynchronizer）队列同步器源码，AQS是用来构建锁或者其他同步组件的基础框架。其主要运用的核心技术点有三个：
- CAS 原子语义，乐观锁
- 维护一个int成员变量表示同步状态。保证该成员变量的可见性
- 维护一个同步队列CLH（FIFO）队列。内部实现是一个双向链表
2.1、AQS队列同步器类结构图
从类结构图中可以看出AbstractQueuedSynchronizer类继承AbstractOwnableSynchronizer。其有2个内部类，分别为Node和ConditionObject。其中ConditionObject会在后面的章节中进行详细分析。其实现类有Sync。Sync在上一章节中进行了详细的分析。
2.2、AbstractOwnableSynchronizer 抽象类源码分析
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;
}
}
2.3、内部类Node源码分析
Node是队列同步器中组成元素。其维护着当前指向的线程，上一个节点的引用，以及下一个节点的引用。
static final class Node {
//标记表示节点正在共享模式中等待
static final Node SHARED = new Node();
//标记表示节点正在独占模式下等待
static final Node EXCLUSIVE = null;
//CANCELLED 值表示线程已取消
static final int CANCELLED = 1;
//SIGNAL 值表示后继者的线程需要被唤醒
static final int SIGNAL = -1;
//CONDITION 值表示线程正在等待条件
static final int CONDITION = -2;
//PROPAGATE 值表示下一个acquireShared应无条件传播
static final int PROPAGATE = -3;
volatile int waitStatus;
// 当前节点的前驱节点
volatile Node prev;
// 当前节点的后续节点
volatile Node next;
// 当前节点指向的线程
volatile Thread thread;
// nextWaiter是“区别当前CLH队列是 ‘独占锁’队列 还是 ‘共享锁’队列 的标记”
// 若nextWaiter=SHARED，则CLH队列是“共享锁”队列；
// 若nextWaiter=EXCLUSIVE，(即nextWaiter=null)，则CLH队列是“独占锁”队列。
Node nextWaiter;
/**
* Returns true if node is waiting in shared mode.
*/
final boolean isShared() {
return nextWaiter == SHARED;
}
/**
* Returns previous node, or throws NullPointerException if null.
* Use when predecessor cannot be null. The null check could
* be elided, but is present to help the VM.
*
* @return the predecessor of this node
* 返回前驱节点
*/
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
}
// Used by addWaiter
Node(Thread thread, Node mode) {
this.nextWaiter = mode;
this.thread = thread;
}
// Used by Condition
Node(Thread thread, int waitStatus) {
this.waitStatus = waitStatus;
this.thread = thread;
}
}
2.4、 AbstractQueuedSynchronizer类的构造函数和成员变量
public abstract class AbstractQueuedSynchronizer
extends AbstractOwnableSynchronizer
implements java.io.Serializable {
// 受保护的构造函数
protected AbstractQueuedSynchronizer() { }
// CLH队列的head节点，除了初始化，仅通过setHead（）方法进行修改
private transient volatile Node head;
// CLH队列的tail节点，修改仅通过方法enq添加新的等待节点
private transient volatile Node tail;
// 同步状态
private volatile int state;
}
AbstractOwnableSynchronizer 内部维护一个同步队列，主要通过双向链表进行维护。没有获得锁的线程，将会被添加到同步队列中。当释放锁的时候，会唤醒队列中的一个节点。
同步队列主要通过成员变量head，tail进行维护。
3、ReentrantLock模拟窗口售票demo
public class ReentrantLockDemo01 implements Runnable {
private Lock lock = new ReentrantLock();
private int tickets = 200;
@Override
public void run() {
while (true) {
lock.lock(); // 获取锁
try {
if (tickets > 0) {
TimeUnit.MILLISECONDS.sleep(100);
System.out.println(Thread.currentThread().getName() + " " + tickets--);
} else {
break;
}
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock(); // 释放所
}
}
}
public static void main(String[] args) {
ReentrantLockDemo01 reentrantLockDemo = new ReentrantLockDemo01();
for (int i = 0; i < 10; i++) {
Thread thread = new Thread(reentrantLockDemo, "thread" + i);
thread.start();
}
}
}
模拟售票的多线程demo。其中主要使用到了lock()获取锁，unlock()释放锁这两个核心方法。我们源码分析从这两个方法分别为出入口进行深入分析。
4、AbstractQueuedSynchronizer 源码分析
4.1、初始化ReentrantLock
Lock lock = new ReentrantLock();
构造函数：
public ReentrantLock() {
// 通过构造函数，构造非公平获得锁，即抢占式获取
sync = new NonfairSync();
}
4.2、 调用lock方法
4.2.1、 调用ReentrantLock的lock方法，其内部是现实调用NonfairSync的lock方法
//ReentrantLock的lock方法
public void lock() {
sync.lock();
}
4.2.2、 NonfairSync的lock方法
final void lock() {
// 通过compareAndSetState方法，进行cas判断，获取当前锁
if (compareAndSetState(0, 1))
// 获取锁成功，设置当前线程为锁拥有线程
setExclusiveOwnerThread(Thread.currentThread());
else
// 获取锁失败，调用acquire方法
acquire(1);
}
调用 acquire(1)，传入参数为1。其中1的作用是用于可重入锁的状态标识。如果当前线程已经拥有锁，直接将当前系统的 state + 1，用于判断当前锁所拥有的句柄数。
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
acquire方法分为2大步骤：tryAcquire(arg) 和 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
4.2.3、 tryAcquire(int arg)
调用NonfairSync的tryAcquire方法，尝试去获取锁
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
调用Sync的nonfairTryAcquire（acquires）非公平尝试获取锁。
final boolean nonfairTryAcquire(int acquires) {
// 获取当前线程
final Thread current = Thread.currentThread();
// 获取当前系统的同步状态变量state
int c = getState();
// 判断当前的系统状态变量是否为0
// 其中0，表示当前锁空闲。大于0表示当前系统锁已经被占用
if (c == 0) {
// 利用CAS原语设置当前state的状态值为1，立刻返回
if (compareAndSetState(0, acquires)) {
// 如果设置成功，表示已经获取当前锁，设置当前锁的拥有者为当前线程
setExclusiveOwnerThread(current);
// 返回获取成功
return true;
}
}
// 如果当前是state不为0，判断当前线程是否已经拥有锁
// 因为ReentrantLock是可冲入锁，所以如果当前线程已经拥有锁的情况下，可以再次使用该锁
else if (current == getExclusiveOwnerThread()) {
// 如果当前线程已经拥有锁，则把当前的 state + 1
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
// 设置当前state的值
setState(nextc);
// 返回成功
return true;
}
return false;
}
首先当前线程会尝试的去获取锁。如果获取失败，判断当前线程是否已经拥有锁。如果已经拥有锁，根据可重入锁的特性，对state + 1操作。
4.2.4、acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
如果第一步已经成功，当前线程获得锁，直接运行结束。如果第一步tryAcquire(arg)获取锁失败。则来到第二个判断。 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)。第二步的判断又可以分为两小步骤进行。下面分别进行分析.
- addWaiter(Node mode)
首先addWaiter的传入参数是Node.EXCLUSIVE，标记表示节点正在独占模式下等待。
addWaiter主要做的事情是，将原来的tail节点，设置为前驱节点，将tail的指针指向当前的node节点，其实就是将node节点追加到队列的尾部，把tail指针下移
private Node addWaiter(Node mode) {
// 实例化当前的node节点。mode为独占模式下的标记，null
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
// 如果当前的tail不为空
if (pred != null) {
// 如果pred不为空，说明当前tail已经存在
node.prev = pred;
// 通过cas快速替换当前tail节点为node节点
if (compareAndSetTail(pred, node)) {
// 将tail节点的next指向node节点，返回node
pred.next = node;
return node;
}
}
如果设置失败的话，调用enq方法
enq(node);
return node;
}
enq(node)方法利用自旋锁的方法，不断的尝试尾部添加，直到添加成功为止
private Node enq(final Node node) {
// 自旋锁，一直尝试添加，直到成功为止
for (;;) {
Node t = tail;
// 如果tail为空，说明当前队列没有节点加入。
if (t == null) { // Must initialize
// 如果tail == null，分别初始化tail和head，第一次初始化，tail == head
if (compareAndSetHead(new Node()))
tail = head;
} else {
//设置当前节点的前驱节点为 tail
node.prev = t;
设置当前的tail 为node节点
if (compareAndSetTail(t, node)) {
//通过上面的步骤，node节点已经执行了tail引用。而原来的tail引用变成了node节点的前驱节点
// 设置tail节点的next为当前的node
t.next = node;
return t;
}
}
}
}
通过addWaiter方法，将当前的线程包装成node节点，添加到队列的尾部。
- acquireQueued(final Node node, int arg)
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
// 死循环，直到满足条件退出
// 首先将当前线程进行阻塞，等待其他线程进行唤醒
// 其他线程进行唤醒以后，判断当前是否获取资源。此时，可能有其他线程的加入，导致获取失败
for (;;) {
// 获取当前节点的前驱节点
final Node p = node.predecessor();
// 如果当前节点的前驱节点是head节点，且尝试获取锁成功
if (p == head && tryAcquire(arg)) {
// 设置当前的node节点为head节点
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 判断当前线程是否应该阻塞
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 如果当前线程被中断，则 parkAndCheckInterrupt()返回为true。interrupted = true
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
4.2.5、shouldParkAfterFailedAcquire(Node pred, Node node)
设置当前node节点的状态值：waitStatus
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
// 如果前驱节点为Node.SIGNAL，直接返回
// Node.SIGNAL 表示后续节点需要唤醒
if (ws == Node.SIGNAL)
return true;
// ws > 0 ,表示当前节点为CANCELLED节点
if (ws > 0) {
// 通过循环，找到 ws < 0 的节点，重新设置node节点的前驱节点
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 设置当前pred的WaitStatus值为 Node.SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
4.2.6、parkAndCheckInterrupt()
private final boolean parkAndCheckInterrupt() {
// 将当前线程进行阻塞挂起,等待其他线程唤醒
LockSupport.park(this);
// 其他线程进行唤醒，返回为fase
return Thread.interrupted();
}
至此，lock()方法调用的分析已经全部完成。如果一个线程获取不到锁，将会被加入到同步器队列中。并且阻塞当前线程，等待其他线程进行唤醒操作。
4.3、 unlock() 源码分析
unlock()方法，主要用来释放当前所拥有的锁资源，同时唤醒下一个节点
4.3.1、unlock() 方法调用
// 调用sync的release方法。该方法的实现是在AbstractQueuedSynchronizer中
public void unlock() {
sync.release(1);
}
//AbstractQueuedSynchronizer中的release方法
public final boolean release(int arg) {
// 尝试去释放当前锁
if (tryRelease(arg)) {
Node h = head;
// 如果 h != null 且 h.waitStatus!=0 的情况下唤醒下一个线程
if (h != null && h.waitStatus != 0)
// 唤醒线程
unparkSuccessor(h);
return true;
}
return false;
}
4.3.2、 tryRelease(int releases) 方法调用
// 当前方法的位置
// java.util.concurrent.locks.ReentrantLock.Sync#tryRelease
protected final boolean tryRelease(int releases) {
// 可重入锁，对当前的state -1
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
// 将当前拥有锁的线程设置为空
setExclusiveOwnerThread(null);
}
// 设置 state的值
setState(c);
return free;
}
4.3.3、 unparkSuccessor(Node node) 方法调用
当前方法传入的参数为head节点
private void unparkSuccessor(Node node) {
// 获取当前node节点的waitStatus
int ws = node.waitStatus;
// 如果当前 ws < 0。通过 cas 设置当前的ws的值为0
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
// 获取当前节点的后驱节点
Node s = node.next;
// 在waitStatus > 0 的情况下。说明当前的节点为CANCELLED
if (s == null || s.waitStatus > 0) {
s = null;
// 一直for循环，直到 t == null 或者 t == head 的情况下结束。
for (Node t = tail; t != null && t != node; t = t.prev)
// 找到节点满足 t.waitStatus <= 0 的节点，并且复制给s
if (t.waitStatus <= 0)
s = t;
}
// 如果 s != null 的情况下，唤醒当前线程。去争取资源
if (s != null)
LockSupport.unpark(s.thread);
}
5、结语
至此，AQS关于lock(),unlock()方法的核心源码已经分析完成。通过源码分析，我们可以深入的理解其获取锁，释放锁的整个过程。后续将分析在Condition的情况下。其核心源码的实现情况。主要完成了以下几件事情：
-
调用自定义同步器的tryAcquire()尝试直接去获取资源，如果成功则直接返回；
-
如果尝试获取资源没有成功，将当前线程封装成Node节点，通过addWaiter()将该线程加入等待队列的尾部，并标记为独占模式；
-
acquireQueued()使线程在等待队列中等待，首先尝试的去获取资源，如果获得到了资源，直接返回。如果没获取到资源，则将当前线程进行阻塞。等到其他线程执行完成对其进行唤醒。
-
如果线程在等待过程中被中断过，当前线程不会立即响应。等到当前线程再次获取执行权以后。进行自我中断。通过selfInterrupt()方法。
101
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
