分析NonfairSync加锁/解锁过程

类继承关系：

NonfairSync => Sync => AbstractQueuedSynchronizer

类NonfairSync

final void lock() {

if (compareAndSetState(0, 1))

setExclusiveOwnerThread(Thread.currentThread());

else

acquire(1);

}

分析：

compareAndSetState(0, 1)：通过cas操作更新state状态，若成功，则获取到锁，否则，进行排队申请操作acquire

类AbstractQueuedSynchronizer

public final void acquire(int arg) {

if (!tryAcquire(arg) &&

acquireQueued(addWaiter(Node.EXCLUSIVE), arg))

selfInterrupt();

}

分析：

tryAcquire方法最终实现为：

类Sync

final boolean nonfairTryAcquire(int acquires) {

final Thread current = Thread.currentThread();

int c = getState();

if (c == 0) {

if (compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);

return true;

}

}

else if (current == getExclusiveOwnerThread()) {

int nextc = c + acquires;

if (nextc < 0) // overflow

throw new Error("Maximum lock count exceeded");

setState(nextc);

return true;

}

return false;

}

通过cas操作更新state状态，若成功，则获取到锁，否则，首先进行排队，

类AbstractQueuedSynchronizer

private Node addWaiter(Node mode) {

Node node = new Node(Thread.currentThread(), mode);

// Try the fast path of enq; backup to full enq on failure

Node pred = tail;

if (pred != null) {

node.prev = pred;

if (compareAndSetTail(pred, node)) {

pred.next = node;

return node;

}

}

enq(node);

return node;

}

注意：

每一个线程被封装成一个Node节点。

进入enq方法——入队列

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;

}

}

}

}

分析：

这里针对head和tail属性的赋值均为cas原子操作。

最终模型如图：

如果多线程并发入队，最终结果如图：

注：prev和next分别为Node类的两个属性

入队操作结束后，开始请求队列acquireQueued

类AbstractQueuedSynchronizer

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())

interrupted = true;

}

} finally {

if (failed)

cancelAcquire(node);

}

}

分析：

1. Node p = node.predecessor()获取node的prev节点
2. 如果prev==head节点并且tryAcquire返回true，则更新head节点为当前节点，并退出循环，也就获取到了锁。
3. 否则的话，执行shouldParkAfterFailedAcquire和parkAndCheckInterrupt。
4. setHead方法来修改head属性，改变队列的头部节点

　　其中，shouldParkAfterFailedAcquire方法是针对waitStatus属性的修改

　　private final boolean parkAndCheckInterrupt() {

　　LockSupport.park(this);

　　return Thread.interrupted();

　　}

　　LockSupport.park(this)，使当前线程进入阻塞。

unlock分析

类AbstractQueuedSynchronizer

public final boolean release(int arg) {

if (tryRelease(arg)) {

Node h = head;

if (h != null && h.waitStatus != 0)

unparkSuccessor(h);

return true;

}

return false;

}

类Sync

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;

}

分析：

主要工作就是设置还原state状态

类AbstractQueuedSynchronizer

private void unparkSuccessor(Node node) {

int ws = node.waitStatus;

if (ws < 0)

compareAndSetWaitStatus(node, ws, 0);

Node s = node.next;

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);

}

分析：

1. 入参node即head节点
2. Node s = node.next;即获取到下一个节点，即正在阻塞中的线程
3. LockSupport.unpark(s.thread);即激活线程