ReentrantLock源码分析

ReentrantLock是一个可重入且独占式的锁,该锁支持获取锁时的公平和非公平选择。

公平锁

公平锁遵循FIFO的原则,所有的线程都会顺序执行

获取锁

1
2
3
4
5
6
7
8
9
10
11
12

//加锁
final void lock() {
acquire(1);
}

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

是否是获得锁,还是进入队列等待的逻辑在tryAcquire 函数里。

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
protected final boolean tryAcquire(int acquires) {
//获取当前线程
final Thread current = Thread.currentThread();

// 获取state值,state代表前线程获取锁的可重入次数
int c = getState();
/** 如果c为0,判断阻塞队列中是否还有线程,
* 如果不存在,设置state的值,并设置当前线程为独占锁的拥有者
* 如果队列中还存在节点,则将该线程加入到队列中。
**/
if (c == 0) {
//判断队列中是否还存在线程
if (!hasQueuedPredecessors() &&
//设置state值
compareAndSetState(0, acquires)) {
// 设置当前线程为独占锁的拥有者
setExclusiveOwnerThread(current);
//返回ture代表获取锁成功
return true;
}
}
/**
* 如果c不为0,判断独占锁的拥有者是否是当前线程,
* 如果是,则修改state值
**/
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
/**返回 false 代表获取锁失败,
* 则AbstractQueuedSynchronizer类的acquire函数继续往下进行,将该线程加入到队列中。
**/
return false;
}


public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}

释放锁

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 public void unlock() {
sync.release(1);
}

//调用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;
}

具体的释放逻辑在release中,free代表该锁是否已完全释放锁,如果为true,AbstractQueuedSynchronizer继续执行release,唤醒队列中的下一个节点;
false则该线程继续持有锁。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//如果当前可重入次数为0 则清空锁持有线程
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);

return free;
}

非公平锁

非公平锁不会关注阻塞队列中是否还有线程,而是直接尝试获取锁,获取不到时在将线程加入到队列中。

获取锁

1
2
3
4
5
6
7
8
9
10
11
12
13
final void lock() {
//修改state的值,修改成功则设值设置当前线程为独占锁的拥有者
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
//调用AbstractQueuedSynchronizer
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}

非公平锁与公平锁的差别在于当c为0时,不去查询队列的状态,而是直接尝试修改state的值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}

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

非公平锁和共平锁的释放锁逻辑相同。

-------------本文结束感谢您的阅读-------------