简述：reentrantLock是java当中提供的一个锁，他和synchronized关键字有所不同，这篇文章主要是从reentrantLock获取锁，然后释放锁，来分析整个底层源码的实现，并不介绍ReentrantLock的具体使用（基于JDK1.8）
ReentrantLock 内部维护了一个Sync类， 这个类的两个有两个实现类，分别是NonfairSync和FairSync ，即非公平锁和公平锁。
我们主要是看下非公平锁，他的类继承关系如下：
对于AQS这个类，是java当中juc包的核心，这篇文章主要是从ReentrantLock的实现方式入手去分析AQS独占式锁的实现方式。juc包的整体实现采用的就是模板模式。通过重写各自需要的tryAcquire，tryRelease等方法即可。
AQS内部结构
static final class Node; // 维护由线程构成的列表
private transient volatile Node head; //线程链表的头结点
private transient volatile Node tail; //线程链表的尾节点
private volatile int state; //状态位 0 - 未被任何线程持有 大于等于1 已经有线程持有static final class Node {
static final Node SHARED = new Node(); // 是否是共享模式
static final Node EXCLUSIVE = null; // 排他模式
static final int CANCELLED = 1; // 取消状态
static final int SIGNAL = -1; // 等待触发状态
static final int CONDITION = -2; //等待唤醒条件
static final int PROPAGATE = -3; // 节点状态需要向后传播
volatile int waitStatus;
volatile Node prev;
volatile Node next;
volatile Thread thread; //当前节点持有的线程
Node nextWaiter; 关于waitStatus的状态说明：
CANCELLED = 1 , 在同步队列中等待的线程等待超时或者被中断，需要从队列当中取消，会将waitStatus的状态置为1，
SIGNAL = -1, 表示其后继节点处于等待状态中，如果当前节点的线程释放了同步状态或者是被取消，会通知后继节点
CONDITION = -2, 线程处于等待condition状态，当其他线程调用signal() 方法，该线程从等待队列当中移动到同步队列中，进行对锁的获取
PROPAGATE = -3, 表示下一次共享式同步状态获取将会无条件被传播下去
nextWaiter: 等待队列中的后继节点，如果当前节点是共享的，nextWaiter是 SHARED常量，也就是说节点类型和等待队列中的后继节点共用同一个字段
基于以上基础架构，来分析ReentrantLocak非公平锁的实现
Lock lock = new ReentrantLock(); lock.lock(); public void lock() {
sync.lock();
}调用NonfairSync代码实现
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}sync继承自AbstractQueuedSynchronizer类，简称AQS, 其内部维护了一个int 类型的state变量，以及当前获取到锁的线程对象thread,
非公平锁，不管当前是否有线程队列在等待获取锁，都直接尝试去获取，成功直接设置AQS当中持有线程为当前线程，否则执行acquire(1)
以上第一步是1、将AQS当中的state状态更改为1，假设现在有三个线程来访问，其中thread1成功将state状态改为1，另外两个线程thread2 和thread3 将执行acquire(1), 以下是AQS当中acquire方法的实现：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}1、先尝试去tryAcquire ，由上面的步骤可知，如果线程1 现在仍然持有锁，并且没有释放，tryAcquire返回的false
2、接下来将线程2和线程3添加到AQS双向链表当中的队尾
tryAcquire的方法实现：
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;
}再次判断thread1是否将锁释放掉了，如果state的值是0，并且线程2成功将状态修改成1，说明线程2获取到锁，返回true
如果当前线程和AQS当中持有的线程是同一个线程，那么就在原来state的基础上添加acquires,并且返回true
否则返回false说明尝试获取锁失败
接下来我们来看下如果获取锁失败后，是如何操作的，addWaiter方法
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}获取到AQS当中node的尾部元素，如果tail是null 的话，执行enq方法
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;
}
}
}
}结合我们上面的场景，线程2和线程3 都没有获取到锁，那么此时tail元素是null , 在这个enq方法当中先创建一个head节点，不包含thread的，然后将thread2添加至node链表的尾部返回
接下来处理队列中的元素
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);
}
}1、先找到当前元素的前一个元素，如果当前元素的前一个元素是head，并且tryAcquire成功了，说明当前链表的前一个元素head可以失效了
2、如果当前元素的前一个元素不是head，或者说当前线程尝试获取锁也失败了，那么执行shouldParkAfterFaildAcquire
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* waitStatus must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}1、如果前一个节点的waitState 是-1，直接返回，然后就是执行&&后面的操作，将当前线程挂起
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}2、如果前一个节点的waitState 大于0，即状态是cancelled ==1 从链表尾部开始查找，找到状态小于等于0 ，并且返回false
3、如果当前状态小于0，且不是signal状态，将pred节点的状态更新为signal
以上就是非共享模式下的AQS实现，整理下执行流程：
1、线程A和线程B同时去获取锁，如果线程A获取成功，会将AQS当中的state改为1，并且将AQS当中的线程指定为当前线程
2、线程B尝试去获取锁失败，这时候会去生成新的node节点（这个节点所有参数都不设置，不包含thread）作为head节点,然后将线程B放在head节点的后面作为tail
3、在放入对列之后，先进行自旋，判断前面的节点是否是head节点，以及当前线程再次尝试获取锁，如果这时候线程A已经执行结束，并且释放掉锁，线程B这时候就不需要进行挂起，直接去执行
4、如果线程B这时候没有获取到锁，判断它前一个节点的状态，如果前一个节点状态是SIGNAL, 将线程B通过LockSupport方式挂起，如果前一个节点状态是CANCELLED状态，那么就会从尾部开始查找，直到waitState小于0，然后将节点waitState改为是SIGNAL状态。
公平锁和非公平锁的区别在于：
在执行lock操作时，公平锁会先去判断阻塞队列当中有没有线程，如果有，将该线程放入到队尾，而非公平锁的操作是，某个线程尝试去获取锁的时候，先执行CAS看是否可以将状态为从0改为1，也就是说，非公平锁拿到锁的这个线程是随机的
公平锁：
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;
}非公平锁：
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;
}关于释放锁的操作：
公平锁和非公平锁对于释放锁的操作是一致的
public final boolean release(int arg) {
if (tryRelease(arg)) {
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;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}1、如果当前线程和持有线程不是同一个线程直接抛出异常，
2、如果释放过后state=0,说明没有任何线程持有锁，会将之前持有的线程置空，返回true
3、尝试释放成功之后，并且head的状态不为0，说明未释放，接下来会unparkSuccess
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
Node s = node.next;
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);
}4、获取到当前head的waitState, 如果小于0，将其通过CAS更新为0
5、找到当前链表当中waitState值小于0的，已经取消的不考虑，最后将waitState小于0的线程，并且唤醒它。
参考：
深度解析Java 8：JDK1.8 AbstractQueuedSynchronizer的实现分析（上）
再谈AbstractQueuedSynchronizer1：独占模式
《java并发编程的艺术》-方腾飞
扫一扫
1372
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
