独占锁Mutex是一个自定义同步组件，它在同一时刻只允许一个线程占有锁。Mutex中定义了一个静态内部类，该内部类继承了同步器并实现了独占式获取和释放同步状态。在tryAcquire(int acquires)方法中，如果经过CAS设置成功（同步状态设置为1），则代表获取了同步状态，而在tryRelease(int releases)方法中只是将同步状态重置为0。用户使用Mutex时并不会直接和内部同步器的实现打交道，而是调用Mutex提供的方法，在Mutex的实现中，以获取锁的lock()方法为例，只需要在方法实现中调用同步器的模板方法acquire(int args)即可，当前线程调用该方法获取同步状态失败后会被加入到同步队列中等待，这样就大大降低了实现一个可靠自定义同步组件的门槛。

五．队列同步器的实现分析

同步器依赖内部的同步队列（一个FIFO双向队列）来完成同步状态的管理，当前线程获取同步状态失败时，同步器会将当前线程以及等待状态等信息构造成为一个节点（Node）并将其加入同步队列，同时会阻塞当前线程，当同步状态释放时，会把首节点中的线程唤醒，使其再次尝试获取同步状态。

5.1 Node

同步队列中的节点（Node）是队列同步器的一个内部类，用来保存获取同步状态失败的线程引用、等待状态以及前驱和后继节点。

static final class Node {//该等待同步的节点处于共享模式static final Node SHARED = new Node();//该等待同步的节点处于独占模式static final Node EXCLUSIVE = null;//等待状态，这个和state是不一样的:有1，0，-1，-2，-3五个值volatile int waitStatus;static final int CANCELLED = 1;static final int SIGNAL = -1;static final int CONDITION = -2;static final int PROPAGATE = -3;volatile Node prev;//前驱节点volatile Node next;//后继节点volatile Thread thread;//等待锁的线程//和节点是否共享有关Node nextWaiter;//Returns true if node is waiting in shared modefinal boolean isShared() {return nextWaiter == SHARED;}
}

waitStatus五个值的含义:

CANCELLED(1):该节点的线程可能由于超时或被中断而处于被取消(作废)状态，一旦处于这个状态，节点状态将一直处于CANCELLED(作废)，因此应该从队列中移除。

SIGNAL(-1):当前节点为SIGNAL时，后继节点会被挂起，因此在当前节点释放锁或被取消之后必须被唤醒(unparking)其后继结点。

CONDITION(-2):该节点的线程处于等待条件状态，在等待队列中，不会被当作是同步队列上的节点，直到被唤醒(signal)，设置其值为0，从等待队列转移到同步队列中，加入到对同步状态的获取中。

PROPAGATE(-3):表示下一次共享式同步状态获取将会无条件传播下去。

0:新加入的节点。

5.2 AQS同步器的结构

节点是构成同步队列的基础，同步器拥有首节点（head）和尾节点（tail）。同步队列的基本结构如下：

同步队列设置尾节点（未获取到锁的线程加入同步队列）: 同步器AQS中包含两个节点类型的引用：一个指向头结点的引用（head)，一个指向尾节点的引用（tail），当一个线程成功的获取到锁（同步状态），其他线程无法获取到锁，而是被构造成节点（包含当前线程，等待状态）加入到同步队列中等待获取到锁的线程释放锁。这个加入队列的过程，必须要保证线程安全。否则如果多个线程的环境下，可能造成添加到队列等待的节点顺序错误，或者数量不对。因此同步器提供了CAS原子的设置尾节点的方法（保证一个未获取到同步状态的线程加入到同步队列后，下一个未获取的线程才能够加入）。  如下图，设置尾节点：

同步队列设置首节点（原头节点释放锁，唤醒后继节点）：同步队列遵循FIFO，头节点是获取锁（同步状态）成功的节点，头节点在释放同步状态的时候，会唤醒后继节点，而后继节点将会在获取锁（同步状态）成功时候将自己设置为头节点。设置头节点是由获取锁（同步状态）成功的线程来完成的，由于只有一个线程能够获取同步状态，则设置头节点的方法不需要CAS保证，只需要将头节点设置成为原首节点的后继节点，并断开原头结点的next引用。如下图，设置首节点：

5.3 独占式同步状态获取

通过调用同步器的acquire(intarg)方法可以获取同步状态，该方法对中断不敏感，也就是

由于线程获取同步状态失败后进入同步队列中，后续对线程进行中断操作时，线程不会从同

步队列中移出。

5.3.1同步器的acquire方法源码

public final void acquire(int arg) {if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();
}

上述代码主要完成了同步状态获取、节点构造、加入同步队列以及在同步队列中自旋等待的相关工作，其主要逻辑是：

(1)当前线程实现通过tryAcquire()方法尝试获取锁，获取成功的话直接返回，如果尝试失败的话，进入等待队列排队等待，可以保证线程安全（CAS）的获取同步状态。

(2)如果尝试获取锁失败的话，构造同步节点（独占式的Node.EXCLUSIVE），通过addWaiter(Node node,int args)方法,将节点加入到同步队列的队列尾部。

(3)最后调用acquireQueued(finalNode node, int args)方法，使该节点以死循环的方式获取同步状态，如果获取不到，则阻塞节点中的线程。acquireQueued方法当前线程在死循环中获取同步状态，而只有前驱节点是头节点的时候才能尝试获取锁（同步状态）（ p == head && tryAcquire(arg)）。

5.3.2addWaiter方法的源码

private Node addWaiter(Node mode) {Node node = new Node(Thread.currentThread(), mode);// Try the fast path of enq; backup to full enq on failureNode pred = tail;if (pred != null) {node.prev = pred;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 initializeif (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 GCfailed = false;return interrupted;}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}

在acquireQueued(final Node node,int arg)方法中，当前线程在“死循环”中尝试获取同步状态，而只有前驱节点是头节点才能够尝试获取同步状态，原因是：

1.头结点是成功获取同步状态的节点，而头结点的线程释放锁以后，将唤醒后继节点，后继节点线程被唤醒后要检查自己的前驱节点是否为头结点。

2.维护同步队列的FIFO原则，节点进入同步队列以后，就进入了一个自旋的过程，每个节点（后者说每个线程）都在自省的观察。

节点自旋获取同步状态的行为如图：

独占式同步状态获取流程，也就是acquire(int arg)方法调用流程，如图

5.4 独占式锁的释放

/*   1. unlock():unlock()是解锁函数，它是通过AQS的release()函数来实现的。* 在这里，“1”的含义和“获取锁的函数acquire(1)的含义”一样，它是设置“释放锁的状态”的参数。* 由于“公平锁”是可重入的，所以对于同一个线程，每释放锁一次，锁的状态-1。unlock()在ReentrantLock.java中实现的，源码如下：*/public void unlock() {sync.release(1);
}

5.4.1 release方法源码

public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;

}

5.4.2 tryRelease方法源码

protected final boolean tryRelease(int releases) {int c = getState() - releases;if (Thread.currentThread() != getExclusiveOwnerThread())throw new IllegalMonitorStateException();boolean free = false;if (c == 0) {free = true;setExclusiveOwnerThread(null);}setState(c);return free;
}

5.4.3unparkSuccessor方法源码

// 4. 唤醒头结点的后继节点
private void unparkSuccessor(Node node) {//获取头结点（线程）的状态int ws = node.waitStatus;//如果状态<0,设置当前线程对应的锁的状态为0if (ws < 0)compareAndSetWaitStatus(node, ws, 0);Node s = node.next;//解释:Thread to unpark is held in successor, which is normally just the next node. //But if cancelled or apparently（显然） null, traverse backwards(向后遍历) from tail to find the actual（实际的） non-cancelled successor（前继节点）.if (s == null || s.waitStatus > 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);}
}

5.5 共享式同步状态获取与释放

public final void acquireShared(int arg) {if (tryAcquireShared(arg) < 0)doAcquireShared(arg);
}
在acquireShared(int arg)方法中，同步器调用tryAcquireShared(int arg)方法尝试获取同步状态，tryAcquireShared(int arg)方法返回值为int类型，当返回值大于等于0时，表示能够获取到同步状态。
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 GCif (interrupted)selfInterrupt();failed = false;return;}}if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;}} finally {if (failed)cancelAcquire(node);}
}

在共享式获取的自旋过程中，成功获取到同步状态并退出自旋的条件就是tryAcquireShared(int arg)方法返回值大于等于0。可以看到，在doAcquireShared(intarg)方法的自旋过程中，如果当前节点的前驱为头节点时，尝试获取同步状态，如果返回值大于等于0，表示该次获取同步状态成功并从自旋过程中退出。

public final boolean releaseShared(int arg) {if (tryReleaseShared(arg)) {doReleaseShared();return true;}return false;
}

在释放同步状态之后，将会唤醒后续处于等待状态的节点。对于能够支持多个线程同时访问的并发组件（比如Semaphore），它和独占式主要区别在于tryReleaseShared(int arg)方法必须确保同步状态（或者资源数）线程安全释放，一般是通过循环和CAS来保证的，因为释放同步状态的操作会同时来自多个线程。