[图解Java]ReentrantLock重入锁

图解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. 以后等待队列的头结点就不需要重新初始化了.