ReentrantLock的原理和应用
- ReentrantLock的构造函数
/**
* Creates an instance of {@code ReentrantLock}.
* This is equivalent to using {@code ReentrantLock(false)}.
*/
public ReentrantLock() {
sync = new NonfairSync();
} /**
* Creates an instance of {@code ReentrantLock} with the
* given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
} -
- 公平锁：AbstractQueuedSynchronizer.tryAquire()的实现会考虑到等待队列。
- 非公平锁：AbstractQueuedSynchronizer.tryAquire()的实现不考虑等待队列。
- ReentrantLock的锁功能的核心Sync类
/** Synchronizer providing all implementation mechanics */
private final Sync sync; Sync在ReentrantLock中有两种实现类：NonfairSync、FairSync，正好对应了ReentrantLock的非公平锁、公平锁两大类型。
下图就是unfairLock.lock()函数内部逻辑流程图，fairLock.lock()内部逻辑类似。
首先，ReentrantLock的lock()方法会调用其内部成员变量sync的lock()方法；
其次，sync的非公平锁NonfairSync或公平锁FairSync实现了父类AbstractQueuedSynchronizer的lock()方法，其会调用acquire()方法；
然后，acquire()方法则在sync父类AbstractQueuedSynchronizer中实现，它只有一段代码：
其次，sync的非公平锁NonfairSync或公平锁FairSync实现了父类AbstractQueuedSynchronizer的lock()方法，其会调用acquire()方法；
然后，acquire()方法则在sync父类AbstractQueuedSynchronizer中实现，它只有一段代码：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
} 上述就是公平锁、非公平锁实现获取锁的主要流程，而针对每种锁来说，其实现方式有很大差别，主要就体现在各自实现类的lock()和tryAcquire()方法中。在sync的抽象类Sync及其抽象父类AbstractQueuedSynchronizer中，lock()方法和tryAcquire()方法被定义为抽象方法或者未实现，而是由具体子类去实现。
- 非公平锁的NonFairSync
- lock方法
/**
* Performs lock. Try immediate barge, backing up to normal
* acquire on failure.
*/
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
这里对于CAS再多说两句，0代表lock没有被持有，而这里第一个参数为0，就代表期望lock没被持有，如果compareAndSet()函数返回true，就代表这个假设正确，那么我们就可以获得这个锁。并将状态设为1，代表lock被持有了一次。
抢占不成功的话，则调用父类的acquire()方法，按照上面讲的，继而会调用tryAcquire()方法，这个方法也是由最终实现类NonfairSync实现的，如下：
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
} -
- tryAquire方法
/**
* Performs non-fair tryLock. tryAcquire is
* implemented in subclasses, but both need nonfair
* try for trylock method.
*/
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来抢占，抢占成功，直接返回true，如果锁的持有者线程为当前线程的话，则通过累加状态标识重入次数。抢占不成功，或者锁的本身持有者不是当前线程，则返回false，继而后续通过进入等待队列的方式排队获取锁。可以通过以下简单的图来理解：
- 公平锁的FairSync
总的来说公平锁的lock方法会先判断等待队列里是否有线程，如果有先给等待队列里的第一个线程分配锁，并将当前主动请求lock的线程加入到等待队列尾。
-
- lock方法
final void lock() {
acquire(1);
} -
- tryAcquire方法
/**
* Fair version of tryAcquire. Don't grant access unless
* recursive call or no waiters or is first.
*/
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;
} 而一旦等待队列中有等待者，或当前线程抢占锁失败，则它会乖乖的进入等待队列排队等待。公平锁的实现大致如下：
