1.lock实现
public void lock() { sync.lock();}我们都知道reentrantlock分为非公平锁和公平锁，通过new ReentrantLock(true);可以变成公平锁
我们这里分析一下jdk1.8时候的lock的实现
公平锁机制下lock调用的源码如下：
final void lock() { acquire(1);}流程图： www.processon.com/view/link/5e3102efe4b05b335ff6b35d
public final void acquire(int arg) {
// 尝试获得锁
if (!tryAcquire(arg) &&
// 获得锁失败则将当前线程变成Node节点add进等待队列
// Node.EXCLUSIVE互斥模式、Node.SHARED共享模式
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}这里先看一下tryAcquire的实现
protected final boolean tryAcquire(int acquires) {
// 获得当前线程
final Thread current = Thread.currentThread();
// 取出锁状态
int c = getState();
// 为0代表还无线程占用
if (c == 0) {
// hasQueuedPredecessors判断等待队列是否初始化，简单来说就是判断当前线程是否是队列中的第一个线程
if (!hasQueuedPredecessors() &&
// CAS，将状态+1
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;
}hasQueuedPredecessors源码：
case 1：当前等待队列未初始化，如果为未初始化则head和tail都为null，那么h != t肯定不成立
case 2：当前等待队列中等于1，则也直接h != t不成立
case 3：当前等待队列中大于1，则&&后的判断，先判断是否还有下一个节点，然后判断当前线程是否和队列中第一个排队的节点的thread相等，不相等则代表有比当前线程更早的获取锁的线程在等待，因为公平锁需要先来后到的执行。返回true，不会进入if。
public final boolean hasQueuedPredecessors() {
Node t = tail;
Node h = head;
Node s;
return h != t &&
((s = h.next) == null || s.thread != Thread.currentThread());
}我们在看acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) 中addWaiter的实现
addWaiter将自己入队，看源码实现：
private Node addWaiter(Node mode) {
// 将当前线程以指定的模式创建节点node
Node node = new Node(Thread.currentThread(), mode);
// 获取当前等待队列的尾节点
Node pred = tail;
// 队列不为空，将新的node加入等待队列中
if (pred != null) {
node.prev = pred;
// CAS方式将当前节点尾插入队列中
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
// 当队列为empty或者CAS失败时会调用enq方法处理
enq(node);
return node;
}
其中，队列为empty，使用enq(node)处理，将当前节点插入等待队列，如果队列为空，则初始化当前队列。所有操作都是CAS自旋的方式进行，直到成功加入队尾为止。
private Node enq(final Node node) {
// 不断自旋
for (;;) {
Node t = tail;
// 当前队列为empty
if (t == null) {
// 完成队列初始化操作，头结点中不放数据，只是作为起始标记，lazy-load，在第一次用的时候new
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;
// 不断将当前节点使用CAS尾插入队列中直到成功为止
// compareAndSetTail(t, node) 判断尾部节点是不是t，是的话就将尾部指向node
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}acquireQueued用于已在队列中的线程以独占且不间断模式获取state状态，直到获取锁后返回。主要流程：
- 结点node进入队列尾部后，检查状态；
- 调用park()进入waiting状态，等待unpark()或interrupt()唤醒；
- 被唤醒后，是否获取到锁。如果获取到，head指向当前结点，并返回从入队到获取锁的整个过程中是否被中断过；如果没获取到，继续流程1
Lock类对于锁的实现不会令线程进入阻塞状态，Lock底层调用LockSupport.park()方法，使线程进入的是等待状态。
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))的实现：
final boolean acquireQueued(final Node node, int arg) {
// 是否已获取锁的标志，默认为true 即为尚未
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;
}
// shouldParkAfterFailedAcquire翻译过来“在获取锁失败之后应该等待”
// shouldParkAfterFailedAcquire根据对当前节点的前一个节点的状态进行判断，对当前节点做出不同的操作
// parkAndCheckInterrupt让线程进入等待状态，并检查当前线程是否被可以被中断
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
// 将当前节点设置为取消状态(Node.CANCELLED),为1
if (failed)
cancelAcquire(node);
}
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// waitStatus默认为0
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 使用CAS将前一个节点状态由 INITIAL 设置成 SIGNAL(这里修改之后会自旋再次尝试获得锁)
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}shouldParkAfterFailedAcquire 方法
-
主要逻辑是使用
compareAndSetWaitStatus(pred, ws, Node.SIGNAL)使用CAS将前一个节点状态由 INITIAL 设置成 SIGNAL，表示当前线程。为什么要设置前一个线程的状态为SIGNAL而不是自己呢？
打个比方，你自己在房间睡着的时候知道自己睡着了吗？当然是不知道，那么你睡着了能自己关门嘛？不能，那你关了门万一没睡呢？所以就需要别人来帮你把门关上。
你也可以理解为修改状态的操作和使线程睡眠的操作不具有原子性，可能出现修改完状态之后却没睡着的情况。
- shouldParkAfterFailedAcquire方法会在死循环中反复重试，直至compareAndSetWaitStatus 设置节点状态位为 SIGNAL 时 shouldParkAfterFailedAcquire 返回 true 时才会执行方法 parkAndCheckInterrupt 方法。
parkAndCheckInterrupt 该方法的关键是会调用 LookSupport.park 方法，该方法是用来当前线程。
waitStatus的各个值都是什么意思：
| 静态变量 | 值 | 描述 |
|---|---|---|
Node.CANCELLED |
1 |
节点对应的线程已经被取消了(我们后边详细会说线程如何被取消) |
Node.SIGNAL |
-1 |
表示后边的节点对应的线程处于等待状态 |
Node.CONDITION |
-2 |
表示节点在等待队列中(稍后会详细说什么是等待队列) |
Node.PROPAGATE |
-3 |
表示下一次共享式同步状态获取将被无条件的传播下去(稍后再说共享式同步状态的获取与释放时详细唠叨) |
| 无 | 0 |
初始状态 |
2.interrupt(),interrupted() 和 isInterrupted() 的区别
interrupt()：将调用该方法的对象所表示的线程标记一个停止标记，并不是真的停止该线程。interrupted()：获取当前线程的中断状态，并且会清除线程的状态标记。是一个是静态方法。
isInterrupted()：获取调用该方法的对象所表示的线程的中断状态，不会清除线程的状态标记。是一个实例方法。
简单的中断案例：t1先执行，但是sleep不释放锁资源，在这期间t2等候两秒钟还没拿到锁就中断
public class Test {
static ReentrantLock lock = new ReentrantLock();
public static void main(String[] args) throws InterruptedException {
Thread t1 = new Thread(() -> {
testsync();
},"t1");
Thread t2 = new Thread(() -> {
testsync();
},"t2");
t1.start();
TimeUnit.SECONDS.sleep(2);
t2.start();
TimeUnit.SECONDS.sleep(2);
System.out.println("main");
/**
* 如果t2两秒钟还拿不到就中断
*/
t2.interrupt();
}
public static void testsync(){
try {
/**
* lockInterruptibly 和 lock的区别，前者会直接抛出异常可以响应中断，后者则不可以
*/
lock.lockInterruptibly();
System.out.println(Thread.currentThread().getName());
TimeUnit.SECONDS.sleep(100);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
lock.unlock();
}
}
}lock和lockInterruptibly的区别就在如下：
public final void acquireInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}
重点在doAcquireInterruptibly方法
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.EXCLUSIVE);
try {
for (;;) {
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
return;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
// 区别在这
throw new InterruptedException();
}
} catch (Throwable t) {
cancelAcquire(node);
throw t;
}
}同acquireQueued() 基本相同，唯一的区别是对中断信号的处理。
acquireQueued() 被中断后，将中断标志传给外界，外界再调用Thread的interrupt() 复现中断；而doAcquireInterruptibly() 则直接抛出InterruptedException。
二者本质上没什么不同。但doAcquireInterruptibly()显示抛出了InterruptedException，调用者必须处理或继续上抛该异常。
3.unlock实现
这里我们看release的实现，sync是reentrantlock的一个内部抽象类，继承了AbstractQueuedSynchronizer
reentrantlock的公平锁FairSync和非公平锁NonfairSync都实现了sync
public void unlock() {
sync.release(1);
}public final boolean release(int arg) {
// 尝试释放锁
if (tryRelease(arg)) {
Node h = head;
// 当waitStatus不为0时，它会唤醒等待队列里的其他线程来获取资源。
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
protected final boolean tryRelease(int releases) {
// 将状态值减1(因为是可重入锁，所以释放锁的次数和加锁的次数要一一对应)
int c = getState() - releases;
// 判断当前线程是否是持有锁的线程
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
// 是否成功释放锁标志，默认为尚未
boolean free = false;
// 当状态值为0就会进行解锁，清空锁持有线程。
if (c == 0) {
free = true;
setExclusiveOwnerThread(null);
}
// 设置可重入次数为原始值0
setState(c);
return free;
}我们继续看unparkSuccessor()：
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
// 如果waitStatus为-1，即表示后边的节点对应的线程处于等待状态
if (ws < 0)
// 将waitStatus改为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);
}这里当unpark唤醒下一个线程的时候，我们之前阻塞的线程就会在acquireQueued这个地方被唤醒，且继续执行
// parkAndCheckInterrupt 这里被唤醒后会获取当前线程的中断状态，并且会清除线程的状态标记。
// 如果没有被中断就if不成立，重新进行for循环
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
for (;;) {
// 获取当前节点的前节点
final Node p = node.predecessor();
// 如果前节点是头结点，则意味着自己是第一个排队的节点，尝试获取锁
if (p == head && tryAcquire(arg)) {
// 成功则将当前节点设置为头结点
setHead(node);
p.next = null; // help GC
failed = false;
// 最后返回false
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}