ReentrantLock重入锁

ReentrantLock是实现Lock接口的一个类，在ReentrantLock中引用了AbstractQueuedSynchronizer的子类，所有的同步操作都是依靠AbstractQueuedSynchronizer（队列同步器）实现.

 

特点：

1：支持重入性，表示能够对共享资源能够重复加锁，即当前线程获取该锁再次获取不会被阻塞。（注：synchronized隐式支持重入性，通过获取自增，释放自减的方式实现重入）

2：ReentrantLock支持两种锁模式，公平锁和非公平锁。默认的实现是非公平的

 

一：重入性实现原理：

1. 在线程获取锁的时候，如果已经获取锁的线程是当前线程的话则直接再次获取成功；2. 由于锁会被获取n次，那么只有锁在被释放同样的n次之后，该锁才算是完全释放成功

 

非公平锁为例：nonfairTryAcquire方法：

final boolean nonfairTryAcquire(int acquires) {

final Thread current = Thread.currentThread();

int c = getState();

//1. 如果该锁未被任何线程占有，该锁能被当前线程获取

if (c == 0) {

if (compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);

return true;

}

}

//2.若被占有，检查占有线程是否是当前线程

else if (current == getExclusiveOwnerThread()) {

// 3. 再次获取，计数加一

int nextc = c + acquires;

if (nextc < 0) // overflow

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

setState(nextc);

return true;

}

return false;

}

 

释放的时候处理思路：tryRelease方法：

rotected final boolean tryRelease(int releases) {

//1. 同步状态减1

int c = getState() - releases;

if (Thread.currentThread() != getExclusiveOwnerThread())

throw new IllegalMonitorStateException();

boolean free = false;

if (c == 0) {

//2. 只有当同步状态为0时，锁成功被释放，返回true

free = true;

setExclusiveOwnerThread(null);

}

// 3. 锁未被完全释放，返回false

setState(c);

return free;

}

 

 

二：公平锁和非公平锁

公平性，是针对获取锁而言的，如果一个锁是公平的，那么锁的获取顺序就应该符合请求上的绝对时间顺序，满足FIFO。

 

ReentrantLock的构造方法无参时是构造非公平锁，源码：

public ReentrantLock() {

sync = new NonfairSync();

}

另外一种方式，可传入一个boolean值，true时为公平锁，false时为非公平锁，源码为：

public ReentrantLock(boolean fair) {

sync = fair ? new FairSync() : new NonfairSync();

}

 

公平锁的处理逻辑 核心方法：

逻辑与nonfairTryAcquire基本上一致，唯一的不同在于增加了hasQueuedPredecessors的逻辑判断，方法名就可知道该方法用来判断当前节点在同步队列中是否有前驱节点的判断，如果有前驱节点说明有线程比当前线程更早的请求资源，根据公平性，当前线程请求资源失败。如果当前节点没有前驱节点的话，再才有做后面的逻辑判断的必要性。公平锁每次都是从同步队列中的第一个节点获取到锁，而非公平性锁则不一定，有可能刚释放锁的线程能再次获取到锁。

protected final boolean tryAcquire(int acquires) {

final Thread current = Thread.currentThread();

int c = getState();

if (c == 0) {

 

if (!hasQueuedPredecessors() &&

compareAndSetState(0, acquires)) {

setExclusiveOwnerThread(current);

return true;

}

}

else if (current == getExclusiveOwnerThread()) {

int nextc = c + acquires;

if (nextc < 0)

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

setState(nextc);

return true;

}

return false;

}

 

公平锁 VS 非公平锁

1：公平锁每次获取到锁为同步队列中的第一个节点，保证请求资源时间上的绝对顺序，而非公平锁有可能刚释放锁的线程下次继续获取该锁，则有可能导致其他线程永远无法获取到锁，造成“饥饿”现象。

 

2：公平锁为了保证时间上的绝对顺序，需要频繁的上下文切换，而非公平锁会降低一定的上下文切换，降低性能开销。因此，ReentrantLock默认选择的是非公平锁，则是为了减少一部分上下文切换，保证了系统更大的吞吐量