图解ReentrantLock
0. demo
我先给出一个demo, 这样大家就可以根据我给的这段代码, 边调试边看源码了. 还是那句话: 注意"My" , 我把ReentrantLock类 改名为了 "MyReentrantLock"类 , "Lock"类 改名为了"MyLock"类. 大家粘贴我的代码的时候, 把相应的"My"都去掉就好了, 否则会编译报错哦.
import java.util.Scanner;
import java.util.function.Supplier;
public class Main {
static final Scanner scanner = new Scanner(System.in);
static volatile String cmd = "";
private static MyReentrantLock lock = new MyReentrantLock(true);
public static void main(String[] args) {
for (String name : new String[]{"1", "2", "3", "4", "5", "6"})
new Thread(() -> func(() -> lock, name)).start();
while (scanner.hasNext()) {
cmd = scanner.nextLine();
}
}
public static void func(Supplier<MyLock> myLockSupplier, String name) {
blockUntilEquals(() -> cmd, "lock " + name);
myLockSupplier.get().lock();
System.out.println("获取了" + name + "号锁");
blockUntilEquals(() -> cmd, "unlock " + name);
myLockSupplier.get().unlock();
System.out.println("释放了" + name + "号锁");
}
private static void blockUntilEquals(Supplier<String> cmdSupplier, final String expect) {
while (!cmdSupplier.get().equals(expect))
quietSleep(1000);
}
private static void quietSleep(int mills) {
try {
Thread.sleep(mills);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
使用例子在下面. 首先线程1申请了锁, 成功申请. 然后线程2申请了锁, 未申请到, 进入等待队列中. 线程3 和 线程4 也申请失败, 进入到等待队列中.
随后释放了锁1, 然后锁2就获取到锁了. 然后释放了锁2, 锁3就获取到锁了...然后是锁4. 大概就是这个使用. 用我的这段代码配合着debug, 可以很清楚地调试出代码的执行流程.
1. 开始图解ReentrantLock
一个ReentrantLock()实例里只有一个sync成员变量.
假设咱们创建了一个公平锁, 那么sync是FairSync类的实例.
sync实例里面有四个成员变量.
分别表示:
1. state - 锁计数器
2. exclusiveOwnerThread - 锁的持有线程
3. head - `等待队列`的头结点.
4. tail - 指向`等待队列`的最后一个元素
现在锁是空闲状态.
当线程1申请了锁, 会把state置为1. 然后把锁的exclusiveOwnerThread指向自己(线程1). 这就算是持有锁了.其他线程无法再获取锁了.只能等线程1释放.
如果线程1在此对这个锁执行了lock()方法呢?
那么就是锁的重入了, 也就是说这个线程再次进入(获取)了这个锁 会让state+1.
再重入呢? 那就再加1....
可以重入多少次呢? 可以重入, 直到整形int溢出为止...
接下来, 线程1还没释放锁呢, 线程2就想获取锁了. 那么会发生什么呢:
把线程2封装为一个Node类型的节点. 然后打算把这个Node放到`等待队列`中去.
这个时候`等待队列`才会被建立, 因为这个时候才需要`等待队列`, 这种叫懒初始化.
这个时候, `等待队列`的头结点产生了. 然后把`等待队列`的tail也指向head.
head或者tail 不为null, 表示`等待队列`被创立了.
head==tail 表示, `等待队列`为空, 里面没有`有效元素`.
`等待队列`有了. 线程2对应的Node也有了. 就差把这个Node插入到队尾了.
首先让tail指向线程2对应的Node.
然后分别维护两个Node的前驱和后继.(看下面紫色箭头)
已经将线程2对应的Node插入到`等待队列`的尾部了, 接下来让线程1对应的Node里的waitState等于-1
之后线程2就可以安心的挂起了. 等线程1完全释放锁的时候, 就会唤醒线程2了.
为什么说是`完全释放`呢? 因为锁的的state现在等于3. 需要线程1 unlock()释放3次锁, 才算是完全释放.
接下来, 线程1还没释放锁呢, (线程2也没轮到锁呢). 线程3就想获取锁了. 那么会发生什么呢:
首先会创建一个线程3对应的Node节点.
然后让尾指针tail指向这个最新的Node.
然后维护前驱和后继(紫色箭头), 来维持双向链表.
接下来就会让新节点的前驱节点的waitStatus = -1.
-1表示, 有下一个节点等待被唤醒.
然后线程3就可以安心的挂起了.
等线程2 抢到锁, 用完了释放后, 就会去唤醒线程3.
咱们让线程1 unlock() 一次.
state减1了.
此时, 锁并没有释放, 还是被线程1持有.
咱们再让线程1 unlock() 一次.
state减1了. 但仍然大于0.
此时, 锁并没有释放, 还是被线程1持有.
咱们再让线程1 unlock() 一次.
state减1了. 这回state等于0了. 表示完全释放了锁.
exclusiveOwnerThread也置为了null, 表示当前的锁不被任何线程持有.
准备唤醒下一个, 也就是`等待队列`的第一个元素(线程2)
线程2被唤醒
然后锁的state被置为了1.
锁的exclusiveOwnerThread指向了线程2. 表示当前锁被线程2持有了.
既然线程1已经完全释放锁了. 那么就换线程2来当`等待队列`的头结点.
所以此时, 头结点的含义就是: 当前持有锁的线程对应的Node结点.
然后断开相应的前驱和后继, 让线程1对应的Node完全脱离`等待队列` .
到此, 线程1释放后, 线程2 获取锁的步骤就都执行完了.
接下来, 咱们让线程2释放锁.
state减1后等于0了.
于是锁就完全释放了. exclusiveOwnerThread就被置为null了.
然后是waitStatus被改回了0. 线程2对应的Node马上就要离开`等待队列`了
线程3被唤醒.
让state=1, 并把锁的exclusiveOwnerThread指向自己. 表示线程3自己独占了这把锁.
修改head指针, 并断开相应的前驱和后继链接, 让线程2对应的Node彻底离开`等待队列`
最后, 咱们让线程3释放锁.
state归零.
exclusiveOwnerThread清空.
锁空闲.
而head和tail仍然指向原先的Node. 以后等待队列的头结点就不需要重新初始化了.
