ReentrantLock
写在前面
类的结构图
一、 简介
ReentrantLock是一个独占的、可重入的、公平/非公平的独占锁。
和AbstractQueuedSynchronizer 的要求一样（源码有注释）。所有lock的实际操作都是通过AbstractQueuedSynchronizer实现的。ReentantLock通过操作内部的Sync对象，操作aqs。Sync继承自AbstractQueuedSynchronizer.重写了一些aqs要求的方法。
- boolean nonfairTryAcquire(int acquires);
- boolean tryRelease(int releases) ;
- boolean isHeldExclusively();
- ConditionObject newCondition();
而Sync作为操作aqs的子类，ReentrantLock有提供了公平和非公平的锁同步机制。
1. 公平和非公平
如何公平或者非公平。
可以通过构造方法，去指定是使用公平还是非公平的锁.无参或者为false的有参构造，使用的都是非公平的锁。
public ReentrantLock() {
sync = new NonfairSync();
}
public ReentrantLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
}
公平和非公平的区别
两者的区别仅仅体现在如何获取锁上。
- NonfairSync的加锁
final void lock() {
if (compareAndSetState(0, 1))
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
非公平锁，都是自己先尝试获取锁，不管别人。
- FairSync的加锁
final void lock() {
acquire(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;
}
}
公平锁，先去看Node中还有没有排队的，如果有排队的，且如果当前线程的Owner不是自己的话（如果是自己可重入），就不让自己获取锁，而是去排队。
2. 可重入
可以从ReenranLock的尝试获取锁的方法，每次获取锁的时候，回先看下当前锁的Owner是不是自~己，如果是自己就让Aqs的state++；然后自己占有锁。
protected final boolean tryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
if (c == 0) {
......
}
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0)
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
return false;
}
}
3. 独占锁
通过setExclusiveOwnerThread(Thread t)，去标记当前锁的持有者。如果锁被占用了，且不是自己的话，就不许别人占锁。这个通过加锁的代码可以看出。
加锁
具体的操作锁的流程都是和AbstractQueuedSynchronizer实现的。
如果AbstractQueuedSynchronizer主要有三部分组成。
- volatile int state;
- final class Node；
- final void setExclusiveOwnerThread(Thread thread)；
通过改成 state值去占锁。state默认是0，代表可以获取锁。大于0代表已经被占有。小于0代表有线程在排队获取锁。如果能通过原子操作能把state从0改成1，就说明可以占锁，这时候把setExclusiveOwnerThread（currentThrad），已经抢锁成功了。
如果0改成1失败，说明占不了锁，这时候就要用到Node，去排队。
流程
场景(非公平)
现在t1,和t2两个线程，t1先抢到锁，t2排队。
- t1 先去占锁，没人抢，把state从0->1，setOwner=t1;
- t2后去占锁，发现state 0->1 失败。这时候Aqs显示调用了一次tryAcquire（1）尝试获取锁。
- 如果这时候t1已经释放锁，ok，那程序到此为止。
- 尝试获取锁失败，t1还在占锁，没有释放。这时候t2就需要去排队了。下面是具体排队的方法
- Aqs调用了acquireQueued(addWaiter(Node.EXCLUSIVE), arg)
- addWaiter(Node.EXCLUSIVE)，主要是在Aqs内部创建了一个有head和tail的Node节点，并且第一次head为一个空的new Node()节点。把t2做为一个尾节点放在head后面。如图上的节点。
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;
}
- acquireQueued(node, arg) 方法是个死循环，里面的方法分两步。
- 获取节点的前一个元素，如果前一个元素为head，再调用一次tryAcquire(arg)。修改node 节点为空head的节点。
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);
}
}
private void setHead(Node node) {
head = node;
node.thread = null;
node.prev = null;
}
- 如果不为head（有很多线程再排队），或者获取锁失败。进行shouldParkAfterFailedAcquire（ pred, node）。
如果当前node 的前一个节点为0，就设置成SIGNAL（-1）.即设置前一个元素的waitSataus=-1.现在t2是第一个排队的。只需要把前面的head的ws改成-1。==循环一次后，返回true。进入parkAndCheckInterrupt()方法== t2 线程一直阻塞到这儿，知道Owner解锁才有机会。
- 如果不为head（有很多线程再排队），或者获取锁失败。进行shouldParkAfterFailedAcquire（ pred, node）。
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
加锁总结
- aqs通过原子操作把自身的state从0改成1，去获取锁，setOwner为自己。
- 再有线程如果不能把state从0改成1，就获取不到锁，进入排队流程。
- 创建空Node为head。设置ws为-1。
- 把当前线程作为第二个节点，挂在head后面，设置tail。如果再有需要排队的，就一直往后挂，设置为tail。
- 调用LockSupport的park，阻塞当前线程。
DDzgJ0.png
解锁
步骤
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
- 释放锁。getSate()-1==0？如果为0，则释放成功。如果不为0，则说明是自己重入了锁。
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;
}
- 释放锁成功，处理排队中的线程。
- 如果Node中的head不为null，且head的waitstatus不为0,<刚刚场景中，head的ws为-1>。执行unparkSuccessor(Node head)。显示设置head的ws为0，然后判断head是有后继节点。<我们的t2就是下个节点，还在park中>。如果后继节点不为null,则unpark(),程序结束。
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); }
解锁总结
解锁比较简单。主要就是owner先释放锁，setSatate=0,setOwner=null。然后去unpark正在排队的线程。unpark的过程也比较简单。就是看有没有head，head的ws是否为-1，如果是-1，就使用LockSupport.unpark(head.next.thrad)。程序中止。
