最近有在看并发编程的艺术一书，确实获益不浅，在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成功后(即原子性成功改变同步状态)后才去真正释放锁。
