java中ReentrantLock实现，公平锁和非公平锁，AQS并发队列,（java 公平锁 非公平锁）
2022-03-01
一般在java中，遇到并发的时候，我们很多时候可能会使用synchronized关键字来实现锁，但是synchronized关键字有一定的缺陷（比如无法实现类似读锁、非公平），而Lock可以实现。在java中常用的有ReentrantLock，我们看下实现，一般我们在代码中如下方式来调用锁：
ReentrantLock lock = new ReentrantLock();
lock.lock();
xxxxxx
lock.unlock();
这里默认的是非公平锁，可以在构造ReentrantLock的时候，传入，指定是公平锁还是非公平锁：
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
我们来看看其实现机制。
在说这个之前，我们需要了解一个类AbstractQueuedSynchronizer，就是常说的并发工具 AQS，java中并发类很多都是基于AQS实现的。
这里说下AQS中几个比较重要的变量：
// 请求链表头
private transient volatile Node head;
// 请求链表尾
private transient volatile Node tail;
// 当前锁被请求次数，为0时表示当前锁空闲 ，实现了可重入（通过state记录锁被请求多少次，只有当state=0的时候，表示锁被释放了）
private volatile int state;
// 这个是父类AbstractOwnableSynchronizer的变量，用来记录当前获取到锁的线程
private transient Thread exclusiveOwnerThread;
当我们调用lock.lock的时候：
public void lock() {
sync.lock();
}
而这里的sync则由两种实现，公平锁和非公平锁，我们先看看公平锁实现：
// FairSync
final void lock() {
acquire(1);
}
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
这里通过acquire获取资源量，每次请求都是1，首先进行tryAcquire,如果tryAcquire失败，那么acquireQueued添加到请求链表中，如果需要中断，那么会中断当前线程。
我们首先看看tryAcquire:
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// c=0 表示当前锁空闲
if (c == 0) {
// hasQueuedPredecessors判断当前是否有请求等待队列
// compareAndSetState如果没有等待队列，利用cas将state设置为当前请求量
// 如果cas设置成功，将exclusiveOwnerThread设置为当前线程
if (!hasQueuedPredecessors() &&
compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
// 如果getExclusiveOwnerThread为当前线程，表示当前线程已经获取到锁了，可重入，调整state
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
可以看到，tryAcquire 方法首先会判断锁的空闲状态，如果锁空闲，通过cas来获取锁，如果锁不空闲，判断是否是当前线程获取到了锁，如果是的话，那么更新state状态，否则返回false
如果tryAcquire返回false，那么会执行acquireQueued(addWaiter(Node.EXCLUSIVE), arg)逻辑：
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
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;
}
}
}
}
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);
}
}
addWaiter主要是通过CAS将请求添加到请求链表的尾部，需要注意的是，传入的mode,·Node.EXCLUSIVE表示独占锁, Node.SHARED共享锁·然后在acquireQueued中，会for死循环来获取锁。而shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()则通过LockSupport.park来阻塞当前线程(这里是通过 LockSupport.park(this);来阻塞当前线程，必须等其他线程调用 LockSupport.unpark(hread);才能被唤醒)。
到这里公平锁获取锁的过程就完了，我们看下怎么释放锁的。
public void unlock() {
sync.release(1);
}
public final boolean release(int arg) {
if (tryRelease(arg)) {
// 如果锁被释放 空闲，并且请求链表不为空，那么通过`LockSupport.unpark`唤醒请求链表头的线程。
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// c==0表示锁空闲，锁已经释放，重置exclusiveOwnerThread 为null
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
可以看到，释放锁的时候，主要是调整了state状态值以及exclusiveOwnerThread，以及如果锁被释放空闲之后，会唤醒请求链表头部的请求来获取锁.
// NonfairSync
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
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;
}
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;
}
可以看到，获取锁的时候，对于非公平锁，上来就是直接获取锁，在获取不到锁的情况下，也是走acquire，但是也公平锁不同的是，非公平锁tryAcquire的时候，并不会关心当前请求队列是否有请求，而是直接通过cas并发获取锁。
这里我们总结下ReentrantLock公平锁和非公平锁的实现逻辑：
公平锁获取锁
1. 如果锁空闲，那么只有当请求链表为空的时候才会去获取锁，获取锁的时候通过cas设置state，并将exclusiveOwnerThread设置为当前线程
2. 如果当前锁的持有线程是当前线程，那么可以直接调整锁的持有量，将state设置为state+acquires，通过cas更新state
3. 如果上面不满足，那么会将当前请求放入到请求队列中 ，并通过LockSupport.park来阻塞请求线程
公平锁释放锁
1 首先通过cas将state线程持有量-acquires
2. 如果state==0，表名当前线程没有地方还需要锁，锁已经全部释放，锁空闲，设置exclusiveOwnerThread为空
3. 如果锁空闲（第二步成功），那么会通过LockSupport.unpark唤醒请求链表的头部线程
非公平锁获取锁
1. 公平锁首先是直接通过cas设置state状态，如果成功，表示获取锁成功（非公平锁不会去判断锁空闲的时候请求链表有没有请求）
2. 如果请求锁失败，那么通过`nonfairTryAcquire`去再次请求，在请求的时候如果锁空闲，不会判断请求链表有没有请求而是直接通过cas获取锁
3. 如果第二步失败，也公平锁一样，加入到请求链表中
非公平锁释放锁
非公平锁释放锁与公平锁一样，没有区别
在ReentrantLock中，获取锁的时候是通过cas设置state变量来实现的，state变量既用来实现锁的获取和释放，又结合exclusiveOwnerThread来实现可重入锁。当state == 0的时候，表示锁空闲，获取锁通过cas设置state ，如果设置成功，则获取锁成功，结合exclusiveOwnerThread，如果exclusiveOwnerThread和当前线程相等，这表示当前线程已经获取到锁了，这时候在获取的话，给state增加accquires，当释放锁的时候，直接通过cas设置state为state - accquires，如果state == 0 则表明当前线程持有的锁变量全部释放完，锁空闲。
当线程获取不到锁的时候，通过LockSupport.park来阻塞线程进行等待，通过LockSupport.unpark来唤醒线程重新请求获取锁