AbstractQueuedSynchronizer源码分析-独占式

独占式获得锁

独占式下的顶层函数为acquire(),首先调用tryAcquire()函数获得锁,如果获取不到锁,则将线程加入到队列中。

1
2
3
4
5
6
7
public final void acquire(int arg) {
if (!tryAcquire(arg) && //尝试获得锁
//将线程加入到对列中,循环获取资源,并在一定次数后阻塞
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
//在阻塞过程中线程可能被中断,忽略中断,在获取到锁后再进行中断。
selfInterrupt();
}

addWaiter()将线程加入到阻塞队列中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
private Node addWaiter(Node mode) {

//将建一个队列节点,并设置该节点为独占模式
Node node = new Node(Thread.currentThread(), mode);
// 尝试快速插入到队列中,失败则调用enq函数
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}

将node节点放入到对尾中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
private Node enq(final Node node) {
for (;;) {
Node t = tail;
//如果队列为空,则设置对尾节点为空,并将队首指向对尾
if (t == null) {
if (compareAndSetHead(new Node()))
tail = head;
} else {
//将该节点的前趋节点设置为当前对列尾节点
node.prev = t;
//将对尾节点设置为尾节点
if (compareAndSetTail(t, node)) {
//将原尾节点的后继指向该节点
t.next = node;
return t;
}
}
}
}

acquireQueued()通过自旋的方式获取同步状态,在需要阻塞线程的时候阻塞线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
//获取当前节点的前趋节点
final Node p = node.predecessor();
//判断前趋节点是否是头节点,如果是,再次掉用tryAcquire尝试获取锁
if (p == head && tryAcquire(arg)) {
//如果获取到锁,则将当前节点设置成头节点
setHead(node);
//在设置头节点时,node的前趋节点已经设置成null,所以这里只将p的next设置成null,p节点将不在队列中
p.next = null; // help GC
failed = false;
return interrupted;
}
//判断是否应该被阻塞,如果应该被阻塞则阻塞该节点
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}

判断是否应该挂起该线程

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
//如果当前节点的前趋节点的状态为SIGNAL则阻塞当前节点
return true;
if (ws > 0) {
do {
//如果当前节点的前趋节点状态>0(CANCELLED),那就一直往前找
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//如果前趋节点为正常状态,则修改前趋节点的状态为SIGNAL,用于线程结束时,唤起下一个节点
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}

挂起线程

1
2
3
4
5
6
private final boolean parkAndCheckInterrupt() {
//阻塞当前线程
LockSupport.park(this);
//当前线程可被中断,返回该线程的中断状态,在该线程获取到锁后,再进行中断
return Thread.interrupted();
}

独占式释放锁

1
2
3
4
5
6
7
8
9
10
public final boolean release(int arg) {
//尝试获释放锁
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
//修改头节点的状态
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);

//获取头节点的下一个节点
Node s = node.next;

//判断s线程是否是null,或线程状态是否是>0(比如CANCELLED状态 代表取消),如果为true,则遍历队列,找到应该被唤醒的线程。
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);
}
-------------本文结束感谢您的阅读-------------