1：公平锁和非公平锁
1.1 流程图
1.2 源码分析
锁使用
final Lock lock = new ReentrantLock();
new Thread(()->{
lock.lock();
try {
System.out.println("--------------------");
Thread.sleep(10000L);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}).start();
1.2.1 CAS尝试获取锁：lock
公平锁：
final void lock() {
acquire(1);
}
非公平锁：
final void lock() {
//尝试获取锁，如果成功就可以获取到
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
//CAS失败，调用acquire进行获取
acquire(1);
}
公平锁中没有直接进行CAS获取锁的流程，为了保证公平，而非公平会直接进行一次尝试。
非公平是作用于新入的节点，而已经调用过addWaiter方法的节点，则需要排队。
两种锁，后面都会调用该方法，主要就是进行获取锁的尝试，如果获取到就退出，如果没有获取到，则需要将当前线程加入到队列中，知道获取到。
public final void acquire(int arg) {
if (!tryAcquire(arg) && //进入1.2.2
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
1.2.2 尝试获取锁tryAcquire(arg)
公平锁和非公平锁的区别是：hasQueuedPredecessors() ，该方法主要是判定是否有线程等待的时长大于当前判断线程。
公平锁：
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
//锁的状态标记，0则是没有进行锁定，>0,则被锁，state值为锁定次数
int c = getState();
//0代表没有被锁定，开始尝试获取
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;
}
其中state是volatile修饰，保证可见，是线程安全的。
1.2.3 添加队列
如果上述获取锁失败，则需要将当前线程加入到队列之中。
（1）：如果队列不为空，则直接加入到队列末尾；
（2）：如果队列为空或者第一步添加失败，则重复进行添加；
ReentranLock中多次运用该思想，先尝试进行，如果没有成功则循环重复进行。
private Node addWaiter(Node mode) {
//创建一个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;
}
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;
}
}
}
}
1.2.4 添加队列后处理
final boolean acquireQueued(final Node node, int arg) {
//标识是否出现异常，出现异常会进入finally，取消获取
boolean failed = true;
try {
//标识线程在等待唤醒期间是否被打断
boolean interrupted = false;
//循环获取，直到获取到或者出现异常
for (;;) {
//当前线程的pre节点
final Node p = node.predecessor();
//如果当前线程可以获取锁，并且获取成功
if (p == head && tryAcquire(arg)) {
//当前节点设置为head
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
//如果节点没有获取到锁，进行判断是否需要进行park
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
先进入：shouldParkAfterFailedAcquire(p, node)
- CANCELLED：值为1，在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该Node的结点，其结点的waitStatus为CANCELLED，即结束状态，进入该状态后的结点将不会再变化。
- SIGNAL：值为-1，被标识为该等待唤醒状态的后继结点，当其前继结点的线程释放了同步锁或被取消，将会通知该后继结点的线程执行。说白了，就是处于唤醒状态，只要前继结点释放锁，就会通知标识为SIGNAL状态的后继结点的线程执行。
- CONDITION：值为-2，与Condition相关，该标识的结点处于等待队列中，结点的线程等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁。
- PROPAGATE：值为-3，与共享模式相关，在共享模式中，该状态标识结点的线程处于可运行状态。
- 0状态：值为0，代表初始化狀態。
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;
}
上述如果返回的true，则标识当前线程进行park：
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
1.2.5 总结
以上为进行加锁的全流程，如果线程添加到队列中或者进入park，如果被唤醒或者开始获取到锁的，那么需要分析持有锁的线程在进行释放的时候做了哪些事情。
1.3 释放锁
public final boolean release(int arg) {
//进行一次锁的释放
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
//唤醒下一个节点的线程
unparkSuccessor(h);
return true;
}
return false;
}
1.3.1 释放锁
protected final boolean tryRelease(int releases) {
//退出一次，则将state减少一次
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
//c=0，标识持有锁的线程已经释放完，并把锁的当前线程置为null
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
1.3.2 唤醒
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
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);
}
可以看出唤醒的是当前节点后面的节点。
2：条件锁
// 声明一个重入锁
ReentrantLock lock = new ReentrantLock();
// 声明一个条件锁
Condition condition = lock.newCondition();
new Thread(()->{
try {
lock.lock(); // 1
try {
System.out.println("before await"); // 2
// 等待条件
condition.await(); // 3
System.out.println("after await"); // 10
} finally {
lock.unlock(); // 11
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}).start();
2.1 ConditionObject介绍
public class ConditionObject implements Condition, java.io.Serializable {
private static final long serialVersionUID = 1173984872572414699L;
/** First node of condition queue. */
private transient Node firstWaiter;
/** Last node of condition queue. */
private transient Node lastWaiter;
}
2.2 await方法
- （1）新建一个节点加入到条件队列中去；
- （2）完全释放当前线程占有的锁；
- （3）阻塞当前线程，并等待条件的出现；
- （4）条件已出现（此时节点已经移到AQS的队列中），尝试获取锁；
// AbstractQueuedSynchronizer.ConditionObject.await()
public final void await() throws InterruptedException {
// 如果线程中断了，抛出异常
if (Thread.interrupted())
throw new InterruptedException();
// 添加节点到Condition的队列中，并返回该节点
Node node = addConditionWaiter();
// 完全释放当前线程获取的锁
// 因为锁是可重入的，所以这里要把获取的锁全部释放
int savedState = fullyRelease(node);
int interruptMode = 0;
// 是否在同步队列中
while (!isOnSyncQueue(node)) {
// 阻塞当前线程
LockSupport.park(this);
// 上面部分是调用await()时释放自己占有的锁，并阻塞自己等待条件的出现
// *************************分界线************************* //
// 下面部分是条件已经出现，尝试去获取锁
if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
break;
}
// 尝试获取锁，注意第二个参数，这是上一章分析过的方法
// 如果没获取到会再次阻塞（这个方法这里就不贴出来了，有兴趣的翻翻上一章的内容）
if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
interruptMode = REINTERRUPT;
// 清除取消的节点
if (node.nextWaiter != null) // clean up if cancelled
unlinkCancelledWaiters();
// 线程中断相关
if (interruptMode != 0)
reportInterruptAfterWait(interruptMode);
}
- （1）Condition的队列和AQS的队列不完全一样；
AQS的队列头节点是不存在任何值的，是一个虚节点；
Condition的队列头节点是存储着实实在在的元素值的，是真实节点。
- （2）各种等待状态（waitStatus）的变化；
首先，在条件队列中，新建节点的初始等待状态是CONDITION（-2）；
其次，移到AQS的队列中时等待状态会更改为0（AQS队列节点的初始等待状态为0）；
然后，在AQS的队列中如果需要阻塞，会把它上一个节点的等待状态设置为SIGNAL（-1）；
最后，不管在Condition队列还是AQS队列中，已取消的节点的等待状态都会设置为CANCELLED（1）；
另外，后面我们在共享锁的时候还会讲到另外一种等待状态叫PROPAGATE（-3）。
- （3）相似的名称；
AQS中下一个节点是next，上一个节点是prev；
Condition中下一个节点是nextWaiter，没有上一个节点。
2.3 signal()方法
public final void signal() {
// 如果不是当前线程占有着锁，调用这个方法抛出异常
// 说明signal()也要在获取锁之后执行
if (!isHeldExclusively())
throw new IllegalMonitorStateException();
Node first = firstWaiter;
//进行通知
if (first != null)
doSignal(first);
}
private void doSignal(Node first) {
do {
if ( (firstWaiter = first.nextWaiter) == null)
lastWaiter = null;
first.nextWaiter = null;
//如果transferForSignal(first)返回false，则指针firstWaiter节点进行后移
} while (!transferForSignal(first) &&
(first = firstWaiter) != null);
}
其中执行：transferForSignal(first)
尝试将当前节点移动到AQS的队列中。这里调用signal()方法后并不会真正唤醒一个节点，真正唤醒的操作是在唤醒的线程执行完释放锁后，会唤醒AQS队列中线程。
final boolean transferForSignal(Node node) {
/*
* If cannot change waitStatus, the node has been cancelled.
*/
if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
return false;
/*
* Splice onto queue and try to set waitStatus of predecessor to
* indicate that thread is (probably) waiting. If cancelled or
* attempt to set waitStatus fails, wake up to resync (in which
* case the waitStatus can be transiently and harmlessly wrong).
*/
Node p = enq(node);
int ws = p.waitStatus;
// 如果上一个节点已取消了，或者更新状态为SIGNAL失败（也是说明上一个节点已经取消了）
// 则直接唤醒当前节点对应的线程
if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
LockSupport.unpark(node.thread);
return true;
}
1：如果更新上一个节点的等待状态为SIGNAL成功了
2：则返回true，这时上面的循环不成立了，退出循环，也就是只通知了一个节点
3：此时当前节点还是阻塞状态
4：也就是说调用signal()的时候并不会真正唤醒一个节点
5：只是把节点从条件队列移到AQS队列中
2.4 流程
3：总结
-
（1）重入锁是指可重复获取的锁，即一个线程获取锁之后再尝试获取锁时会自动获取锁；
-
（2）在ReentrantLock中重入锁是通过不断累加state变量的值实现的；
-
（3）ReentrantLock的释放要跟获取匹配，即获取了几次也要释放几次；
-
（4）ReentrantLock默认是非公平模式，因为非公平模式效率更高；
-
（5）条件锁是指为了等待某个条件出现而使用的一种锁；
-
（6）条件锁比较经典的使用场景就是队列为空时阻塞在条件notEmpty上；
-
（7）ReentrantLock中的条件锁是通过AQS的ConditionObject内部类实现的；
-
（8）await()和signal()方法都必须在获取锁之后释放锁之前使用；
-
（9）await()方法会新建一个节点放到条件队列中，接着完全释放锁，然后阻塞当前线程并等待条件的出现；
-
（10）signal()方法会寻找条件队列中第一个可用节点移到AQS队列中；
-
（11）在调用signal()方法的线程调用unlock()方法才真正唤醒阻塞在条件上的节点（此时节点已经在AQS队列中）；
-
（12）之后该节点会再次尝试获取锁，后面的逻辑与lock()的逻辑基本一致了。