AQS系列——独占式操作逻辑

一、阅读源码的背景

很多人奇怪，阅读源码还能有什么背景，就是为了写好代码呗。其实也不尽然，就算不看源码，也不影响我们写好代码。我看源码，纯粹为了面试，嗯，没错，就是为了面试。事情的经过是这样子的：前一段时间，博主为了面试，粗略的看了一下AQS的源码；接着面试的时候就和面试官扯，我刚看了AQS的源码；那么面试官就问博主，AQS是怎么管理线程的呀；嗯，博主心想，这么简单，就回了一句用了一个单向阻塞队列呀；哦吼，直接把面试官气到不想说话，草草结束面试。废话不多说，直接上图，上源码。

二、AQS的简易结构

此处省略千千万万字…直接看图，我把一切都留在图上了

三、AQS独占式获取资源逻辑

看这里的逻辑的时候，可以结合 ReentrantReadWriteLock 或 ReentrantLock 一起看；

四、AQS独占式释放资源逻辑

这里同样可以结合 ReentrantReadWriteLock 或 ReentrantLock 一起看；

五、源码解析

兄弟姐妹们，终于到了你们最喜欢的环节，源码解读，废话不多说直接上代码，温馨提示你们，最好结合上面的图片来看，还有就是打开你的idea，跟着这里的注释好好捋一捋代码的逻辑；篇幅比较长，我给你们划下重点：
1. 准备好瓜子；
2. 准备好可乐；
3. 带上脑子开淦；
1. AQS独占式获取资源源码

// 独占式获取临界资源的入口；
public final void acquire(int arg) {
	if (!tryAcquire(arg) &&
		acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
		selfInterrupt();
}
// 需要业务实现，具体获取临界资源的逻辑；
protected boolean tryAcquire(int arg) {
	throw new UnsupportedOperationException();
}
// 将当前线程对应的节点加入队列；
private Node addWaiter(Node mode) {
	Node node = new Node(Thread.currentThread(), mode);
	Node pred = tail;
	if (pred != null) {
		node.prev = pred;
		// 采用CAS机制设置队列的尾结点为当前节点；
		if (compareAndSetTail(pred, node)) {
			pred.next = node;
			return node;
		}
	}
	enq(node);
	return node;
}
// 循环将当前节点加入队列；
private Node enq(final Node node) {
	// 开启循环;
	for (;;) {
		Node t = tail;
		if (t == null) { // Must initialize
			// 如果当前队列为空，将当前节点设置为头尾节点；
			if (compareAndSetHead(new Node()))
				tail = head;
		} else {
			node.prev = t;
			if (compareAndSetTail(t, node)) {
				t.next = node;
				return t;
			}
		}
	}
}
// 挂起线程，等待任务执行；
final boolean acquireQueued(final Node node, int arg) {
	boolean failed = true;
	try {
		boolean interrupted = false;
		for (;;) {
			final Node p = node.predecessor();
			if (p == head && tryAcquire(arg)) {
				// 如果上一个节点为头结点，且获取资源成功，设置当前节点为头结点；
				setHead(node);
				p.next = null; // help GC
				failed = false;
				return interrupted;
			}
			if (shouldParkAfterFailedAcquire(p, node) &&
				parkAndCheckInterrupt())
				// 如果线程被中断，更改中断状态为true；
				interrupted = true;
		}
	} finally {
		if (failed)
			cancelAcquire(node);
	}
}
// 设置当前节点为头结点；
private void setHead(Node node) {
	head = node;
	node.thread = null;
	// 细节，删除上一个节点的引用链，help GC；
	node.prev = null;
}
// 检查上一个节点是否处于等待唤醒的状态；
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
	int ws = pred.waitStatus;
	if (ws == Node.SIGNAL)
		// 如果上一个节点的等待状态为-1，表示等待唤醒，即是正常；
		return true;
	if (ws > 0) {
		// 大于0表示被取消，需要当前节点重新定位上一个节点
		do {
			node.prev = pred = pred.prev;
		} while (pred.waitStatus > 0);
		pred.next = node;
	} else {
		compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
	}
	return false;
}
// 挂起当前线程，等待上一个节点任务执行完后唤醒；
private final boolean parkAndCheckInterrupt() {
	// 唤醒的方法：unparkSuccessor(Node node)；
	LockSupport.park(this);
	// 唤醒之后，检查当前线程是否被中断；
	return Thread.interrupted();
}
// 取消当前节点任务；
private void cancelAcquire(Node node) {
	if (node == null)
		return;
	node.thread = null;
	Node pred = node.prev;
	while (pred.waitStatus > 0)
		node.prev = pred = pred.prev;
	Node predNext = pred.next;
	node.waitStatus = Node.CANCELLED;
	if (node == tail && compareAndSetTail(node, pred)) {
		compareAndSetNext(pred, predNext, null);
	} else {
		int ws;
		if (pred != head &&
			((ws = pred.waitStatus) == Node.SIGNAL ||
			 (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
			pred.thread != null) {
			Node next = node.next;
			if (next != null && next.waitStatus <= 0)
				compareAndSetNext(pred, predNext, next);
		} else {
			unparkSuccessor(node);
		}
		node.next = node; // help GC
	}
}

2. AQS独占式释放资源源码

// 释放资源入口；
public final boolean release(int arg) {
	if (tryRelease(arg)) {
		Node h = head;
		if (h != null && h.waitStatus != 0)
			unparkSuccessor(h);
		return true;
	}
	return false;
}
// 待业务实现，比如：ReentrantLock、ReentrantReadWriteLock
protected boolean tryRelease(int arg) {
	throw new UnsupportedOperationException();
}
// 唤醒下一个节点；
private void unparkSuccessor(Node node) {
	int ws = node.waitStatus;
	if (ws < 0)
		// 小于0表示当前任务未完成，需要将状态设置为0；
		compareAndSetWaitStatus(node, ws, 0);
	Node s = node.next;
	if (s == null || s.waitStatus > 0) {
		// 如果下一个节点状态大于0表示已取消，需要重新整理队列；
		s = null;
		for (Node t = tail; t != null && t != node; t = t.prev)
			if (t.waitStatus <= 0)
				s = t;
	}
	if (s != null)
		// 唤醒下一个节点对应的线程；
		LockSupport.unpark(s.thread);
}

六、总结

嗯，一路下来是不是觉得还不够爽，不够爽的话可以继续看AQS的共享式资源操作；篇幅有限，我这里就写这么多。 在文末也祝愿那些面试者，不再担心AQS源码问题；不过呢，自己也做过面试官，实际上大家不用太担心源码问题，面试官问你源码，更多的是想看看你对技术的钻研精神，还有就是体现一下自己比较牛皮，实际上也可能像我这种半吊子，没看过源码就面试你们的人，大家不用怕面试官，面试官最关心的还是你解决问题的能力，知识是在解决问题的时候才产生了价值，屯在脑子里只能遗忘。