公平锁解锁
解锁可以分解成两个步骤：
- 解锁
- 唤醒等待线程
// 解锁操作
public void unlock() {
sync.release(1);
}
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) {
// 计算解锁后的state
int c = getState() - releases;
// 如果解锁线程和持有锁的线程不是一个线程，那么直接抛异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
// 如果c解锁后等于0，那么说明这个线程完全不持有锁了
if (c == 0) {
// 解锁成功
free = true;
// 把持有锁的线程引用置为null
setExclusiveOwnerThread(null);
}
// 设置解锁后state值。
// 这个解锁有可能是在多次lock后执行unlock
// 这样的话，持有锁的线程还是当前线程，只不过state减少
setState(c);
// 返回解锁结果
return free;
}
示例：
// 创建一个公平锁
ReentrantLock lock = new ReentrantLock(true);
try{
// 竞争锁
lock.lock();
// 执行业务逻辑
System.out.println("hello world");
}finally{
// 解锁
// state=0，并且setExclusiveOwnerThread(null)
lock.unlock();
}
// 创建一个公平锁
ReentrantLock lock = new ReentrantLock(true);
try{
// 竞争锁
lock.lock();
// 执行业务逻辑
System.out.println("hello world");
try{
// 锁重入
lock.lock();
// 执行业务逻辑
System.out.println("再次获取锁");
}finally{
// 第一次解锁。
// state=state-1
lock.unlock();
}
}finally{
// 再次解锁。
// state=0, setExclusiveOwnerThread(null)
lock.unlock();
}
- 唤醒等待线程
private void unparkSuccessor(Node node) {
// 获取头节点状态
int ws = node.waitStatus;
// 如果head节点状态小于0，
if (ws < 0)
// 把头节点状态设置为0
node.compareAndSetWaitStatus(ws, 0);
// 获取头节点下一个节点
Node s = node.next;
// 如果下一个节点为空，或者下一个节点状态是“取消”状态
if (s == null || s.waitStatus > 0) {
s = null;
// 通过从后向前遍历，寻找最靠近头节点的状态小于等于0的节点
for (Node p = tail; p != node && p != null; p = p.prev)
if (p.waitStatus <= 0)
s = p;
}
if (s != null)
// 如果存在靠近头节点，并且状态小于等于0的节点
// 那么直接唤醒该节点
LockSupport.unpark(s.thread);
}
在上面的解锁过程中，一直没有看到任何处理head节点的代码。理论上来说，head节点在解锁后就应该没有任何变量引用它，那么head节点是在什么时候被处理掉的呢？
其实答案在下面的代码中：
final boolean acquireQueued(final Node node, int arg) {
// 默认线程未被打断
boolean interrupted = false;
try {
// 开启自旋
for (;;) {
// 获取当前节点的前一个节点
final Node p = node.predecessor();
// 如果前一个节点是head节点，那么就尝试竞争锁
if (p == head && tryAcquire(arg)) {
// 竞争锁成功，把当前节点设置为head节点
setHead(node);
// 把前一个节点和当前节点断开
// 因为当前节点已经设置为head节点了，之前的head就可以GC了
p.next = null; // help GC
// 返回是否当前线程被打断。
// 这个返回结果的作用会被用在lockInterruptibly()这个方法上。
// lock()方法可忽略。
return interrupted;
}
// 判断当前节点是否应该阻塞。
if (shouldParkAfterFailedAcquire(p, node))
// 下面这个代码可以翻译成：
// if(parkAndCheckInterrupt()){
// interrupted = true;
// }
interrupted |= parkAndCheckInterrupt();
}
} catch (Throwable t) {
// 抛出任何异常，都直接取消当前节点正在竞争锁的操作
// 如果在等待队列中，就从等待队列中移除。
// 如果当前线程已经抢占到锁了，那么就解锁。
cancelAcquire(node);
// 如果当前线程已经被中断
if (interrupted)
// 重新设置中断信号
selfInterrupt();
// 抛出当前异常
throw t;
}
}
当等待队列中的节点竞争到锁后，会把自己变成head节点，之前的head节点就断开所有的引用，直至被GC。
