最近有在看并發編程的藝術一書，確實獲益不淺，在java并發編程的思想領悟上有很大的進步。第五章節Java中的鎖核心內容在同步器AbstractQueuedSynchronizer類上，此處將記錄一下個人關于這一章節的讀后感。
Lock面對使用者，同步器面對實現者
文中也有說到這句話。我們經常需要寫一個自定義鎖去實現Lock接口來滿足業務實現，如果你正好是這項任務的負責人，你就是那個實現者，你需要很好地理解同步器(AbstractQueuedSynchronizer)的工作原理，你才能寫得出來。寫出來后，供他人使用，它們就是使用者，他們只會使用自定義鎖(同步組件,實現Lock接口的類)實現的方法，如lock()，unlock()等。
一下是文中的一份示例代碼:
public class Mutex implements Lock {
// 靜態內部類，自定義同步器
private static class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -4387327721959839431L;
// 是否處于占用狀態
protected boolean isHeldExclusively() {
return getState() == 1;
}
// 當狀態為0的時候獲取鎖
public boolean tryAcquire(int acquires) {
assert acquires == 1; // Otherwise unused
if (compareAndSetState(0, 1)) {
setExclusiveOwnerThread(Thread.currentThread());
return true;
}
return false;
}
// 釋放鎖，將狀態設置為0
protected boolean tryRelease(int releases) {
assert releases == 1; // Otherwise unused
if (getState() == 0)
throw new IllegalMonitorStateException();
setExclusiveOwnerThread(null);
setState(0);
return true;
}
// 返回一個Condition，每個condition都包含了一個condition隊列
Condition newCondition() {
return new ConditionObject();
}
}
// 僅需要將操作代理到Sync上即可
private final Sync sync = new Sync();
public void lock() {
sync.acquire(1);
}
public boolean tryLock() {
return sync.tryAcquire(1);
}
public void unlock() {
sync.release(1);
}
public Condition newCondition() {
return sync.newCondition();
}
public boolean isLocked() {
return sync.isHeldExclusively();
}
public boolean hasQueuedThreads() {
return sync.hasQueuedThreads();
}
public void lockInterruptibly() throws InterruptedException {
sync.acquireInterruptibly(1);
}
public boolean tryLock(long timeout, TimeUnit unit) throws InterruptedException {
return sync.tryAcquireNanos(1, unit.toNanos(timeout));
}
我們從使用者的角度出發來看，假設你現在調用了mutex.lock()方法，也就是調用了自定義鎖的lock()方法，它實際調用的是sync.acquire(1)方法，sync就是同步器，你幾乎所有作用在鎖上的方法全部都由同步器來實現。再看同步器都提供了哪些方法?示例中同步器主要提供了獲取鎖和釋放鎖的方法，具體信息詳見代碼注釋。由代碼可以分析出這是一個互斥鎖(獨占鎖)，同一時刻只能有一個線程占有鎖。
同步器都提供了哪些方法呢?
同步器主要提供了兩類方法，分別是同步器可重寫的方法和同步器的模板方法。同步器的模板方法，通常由鎖在實現接口方法時直接調用，幾乎不用修改。而模板方法內部會再去調用同步器重寫的方法。如示例中鎖的lock方法，調用的是同步器的模板方法acquire(1)，而acquire(1)會調用可重寫的方法tryAcquire(1)。
那么同步器可重寫的方法有哪些呢?
經查閱同步器(AbstractQueueSynchronizer)源碼，發現這個抽象類中可重寫的方法，都有一個共同特點，就是都是protected修飾的，而且方法體內是拋出一個UnsupportedOperationException運行時異常，這表明作者是期待鎖的實現者重寫這些方法的。這些方法有:
- boolean tryAcquire(int arg)
- boolean tryRelease(int arg)
- int tryAcquireShared(int arg)
- boolean tryReleaseShared(int arg)
- boolean isHeldExclusively()
具體使用不做特別說明。至于同步器的模板方法這里也不做說明，你可以查閱相關資料。
同步器的實現分析
關鍵詞： 同步隊列節點 Node 等待狀態 首節點 尾節點 獨占式 共享式
同步器內部主要由一個同步隊列維護同步狀態的獲取與釋放。同步隊列是由一個個節點Node串聯而成的一個雙向列表。
- 頭節點是成功獲取到同步狀態的節點。
- 同步隊列遵循FIFO原則。
從TwinsLock看共享式獲取同步狀態
關于共享式獲取同步狀態，書中是前面介紹原理，最后通過一個demo來加深讀者的理解。其實，我個人更想由示例入手，慢慢分析，抽絲剝繭，來看共享式獲取同步狀態是怎么做到的？
在這之前，也許你需要理解一下什么是自旋？什么是自旋鎖？什么場景適合使用自旋鎖？具體可參考java鎖的種類以及辨析（一）：自旋鎖
TwinsLock示例代碼:
public class TwinsLock implements Lock {
private final Sync sync = new Sync(2);
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = -7889272986162341211L;
Sync(int count) {
if (count <= 0) {
throw new IllegalArgumentException("count must large than zero.");
}
setState(count);
}
public int tryAcquireShared(int reduceCount) {
for (;;) {
int current = getState();
int newCount = current - reduceCount;
if (newCount < 0 || compareAndSetState(current, newCount)) {
return newCount;
}
}
}
public boolean tryReleaseShared(int returnCount) {
for (;;) {
int current = getState();
int newCount = current + returnCount;
if (compareAndSetState(current, newCount)) {
return true;
}
}
}
final ConditionObject newCondition() {
return new ConditionObject();
}
}
public void lock() {
sync.acquireShared(1);
}
public void unlock() {
sync.releaseShared(1);
}
public void lockInterruptibly() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public boolean tryLock() {
return sync.tryAcquireShared(1) >= 0;
}
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
return sync.tryAcquireSharedNanos(1, unit.toNanos(time));
}
@Override
public Condition newCondition() {
return sync.newCondition();
}
}
先說明一些重要信息，同步狀態的初始值為2，有效值共有0、1、2，當為0時，表示已有兩個線程獲取到了同步狀態，此時再有其他線程對同步狀態進行獲取，該線程只能被阻塞。
從lock()方法看起，它調用了sync.acquireShared(1)方法，這是同步器的一個模板方法，這個模板方法又調用了同步器可重寫的方法tryAcquireShared(args)，如下:
public final void acquireShared(int arg) {
if (tryAcquireShared(arg) < 0)
doAcquireShared(arg);
}
這個代碼片段的意思就是，獲取的同步狀態如果<0，表示鎖已被占用，此時不可獲取鎖，需要調用doAcquireShared(args)(注:這個方法內會發生自旋，直至獲取到鎖)，如下:
/**
* Acquires in shared uninterruptible mode.
* @param arg the acquire argument
*/
private void doAcquireShared(int arg) {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {
setHeadAndPropagate(node, r);
p.next = null; // help GC
if (interrupted)
selfInterrupt();
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
那么再來看共享式如何釋放同步狀態?,與獨占式釋放同步狀態相比較，必須確保同步狀態線程安全釋放（因為共享式有多個線程可以同時占有鎖），一般是通過循環和CAS實現的。
還是看上面的共享式鎖，unlock()方法調用了模板方法sync.releaseShared(1)方法，看下模板方法是如何寫的，如下:
public final boolean releaseShared(int arg) {
//嘗試釋放同步狀態，成功則調用同步器固定的doReleaseShared()方法
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}
查看示例代碼中可重寫的同步器方法tryReleaseShared(args)方法，
public boolean tryReleaseShared(int returnCount) {
for (;;) {
int current = getState();
int newCount = current + returnCount;
if (compareAndSetState(current, newCount)) {
return true;
}
}
}
你會發現這是一個自旋方法，內部通過循環判斷CAS成功后(即原子性成功改變同步狀態)后才去真正釋放鎖。
