网络知识 娱乐 ReentrantLock可重入、可打断、锁超时实现原理

ReentrantLock可重入、可打断、锁超时实现原理

概述

前面讲解了ReentrantLock加锁和解锁的原理实现,但是没有阐述它的可重入、可打断以及超时获取锁失败的原理,本文就重点讲解这三种情况。建议大家先看下这篇文章了解下ReentrantLock加锁的基本原理,图解ReentrantLock公平锁和非公平锁实现。

可重入

可重入是指一个线程如果获取了锁,那么它就是锁的主人,那么它可以再次获取这把锁,这种就是理解为重入,简而言之,可以重复获取同一把锁,不会造成阻塞,举个例子如下:

@Testn public void testRepeatLock() {n ReentrantLock reentrantLock = new ReentrantLock();n // 第一次获取锁n reentrantLock.lock();n try {n System.out.println(Thread.currentThread().getName() + " first get lock");n // 再次获取锁n tryAgainLock(reentrantLock);n }finally {n reentrantLock.unlock();n }n }nn public void tryAgainLock(ReentrantLock reentrantLock) {n // 第2次获取锁n reentrantLock.lock();n try {n System.out.println(Thread.currentThread().getName() + " second get lock");n }finally {n reentrantLock.unlock();n }n }n复制代码

  • 同一个线程使用ReentrantLock多次获取锁,不会阻塞
  • 申请几把锁,最后需要解除几把锁

那你知道是怎么实现的吗?

概述的文章中已经讲解了ReentrantLock整个的加锁和解锁的过程,可重入实现就在其中,这里着重关注下申请锁的方法tryAcquire,最终会调用nonfairTryAcquire方法。

  1. 如果已经有线程获得了锁, 并且占用锁的线程是当前线程, 表示【发生了锁重入】,上图的1步骤
  2. 计算出冲入的次数nextc等于当前次数+新增次数,acquires等于1
  3. 更新 state 的值,这里不使用 cas 是因为当前线程正在持有锁,所以这里的操作相当于在一个管程内, 然后返回ture,表明再次申请锁成功。

可打断

ReentrantLock相比于synchronized加锁一大优势是可打断,那么什么是可打断呢?ReentrantLock通过lockInterruptibly()加锁,如果一直获取不到锁,可以通过调用线程的interrupt()提前终止线程。举个例子:

@Testn public void testInterrupt() throws InterruptedException {n ReentrantLock lock = new ReentrantLock();nn // 主线程普通加锁n System.out.println("主线程优先获取锁");n lock.lock();n try {n // 创建子线程n Thread t1 = new Thread(() -> {n try {n System.out.println("t1尝试获取打断锁");n lock.lockInterruptibly();n } catch (InterruptedException e) {n System.out.println("t1没有获取到锁,被打断,直接返回");n return;n }n try {n System.out.println("t1成功获取锁");n } finally {n System.out.println("t1释放锁");n lock.unlock();n }n }, "t1");n t1.start();n Thread.sleep(2000);n System.out.println("主线程进行打断锁");n t1.interrupt();n } finally {n // 主线程解锁n System.out.println("主线程优先释放锁");n lock.unlock();n }n }n复制代码

  • 通过lockInterruptibly()方法获取锁期间,可以通过线程的interrupt()方法进行中断,跳出阻塞。
  • 通过lock()方法获取锁,不会响应interrupt()方法的中断。

接下来我们看看它的实现原理。

public void lockInterruptibly() throws InterruptedException { n sync.acquireInterruptibly(1);n}npublic final void acquireInterruptibly(int arg) {n // 被其他线程打断了直接返回 falsen if (Thread.interrupted())nttthrow new InterruptedException();n if (!tryAcquire(arg))n // 没获取到锁,进入这里n doAcquireInterruptibly(arg);n}n复制代码

  • 先判断一次线程是否中断了,是的话,直接抛出中断异常。
  • 如果没有获取锁,调用doAcquireInterruptibly()方法。

private void doAcquireInterruptibly(int arg) throws InterruptedException {n // 封装当前线程,加入到队列中n final Node node = addWaiter(Node.EXCLUSIVE);n boolean failed = true;n try {n // 自旋n for (;;) {n // shouldParkAfterFailedAcquire判断是否需要阻塞等待n // parkAndCheckInterrupt方法是阻塞线程,返回true,表示线程被中断了n if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())n // 【在 park 过程中如果被 interrupt 会抛出异常】, 而不会再次进入循环获取锁后才完成打断效果n throw new InterruptedException();n } n } finally {n // 抛出异常前会进入这里n if (failed)n // 取消当前线程的节点n cancelAcquire(node);n }n}n复制代码

  • addWaiter将当前线程封装成节点,加入到队列中。
  • shouldParkAfterFailedAcquire()方法判断如果前一个节点的等待状态时-1,则返回true,表示当前线程需要阻塞。
  • parkAndCheckInterrupt()方法是阻塞线程,返回true,表示线程被中断了,抛出InterruptedException异常。
  • 最后调用cancelAcquire()方法,将当前节点状态设置为cancel取消状态。

// 取消节点出队的逻辑nprivate void cancelAcquire(Node node) {n // 判空n if (node == null)n return;nt// 把当前节点封装的 Thread 置为空n node.thread = null;nt// 获取当前取消的 node 的前驱节点n Node pred = node.prev;n // 前驱节点也被取消了,循环找到前面最近的没被取消的节点n while (pred.waitStatus > 0)n node.prev = pred = pred.prev;n nt// 获取前驱节点的后继节点,可能是当前 node,也可能是 waitStatus > 0 的节点n Node predNext = pred.next;n nt// 把当前节点的状态设置为 【取消状态 1】n node.waitStatus = Node.CANCELLED;n nt// 条件成立说明当前节点是尾节点,把当前节点的前驱节点设置为尾节点n if (node == tail && compareAndSetTail(node, pred)) {n // 把前驱节点的后继节点置空,这里直接把所有的取消节点出队n compareAndSetNext(pred, predNext, null);n } else {n // 说明当前节点不是 tail 节点n int ws;n // 条件一成立说明当前节点不是 head.next 节点n if (pred != head &&n // 判断前驱节点的状态是不是 -1,不成立说明前驱状态可能是 0 或者刚被其他线程取消排队了n ((ws = pred.waitStatus) == Node.SIGNAL ||n // 如果状态不是 -1,设置前驱节点的状态为 -1n (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&n // 前驱节点的线程不为nulln pred.thread != null) {n n Node next = node.next;n // 当前节点的后继节点是正常节点n if (next != null && next.waitStatus <= 0)n // 把 前驱节点的后继节点 设置为 当前节点的后继节点,【从队列中删除了当前节点】n compareAndSetNext(pred, predNext, next);n } else {n // 当前节点是 head.next 节点,唤醒当前节点的后继节点n unparkSuccessor(node);n }n node.next = node; // help GCn }n}n复制代码

锁超时

ReentrantLock还具备锁超时的能力,调用tryLock(long timeout, TimeUnit unit)方法,在给定时间内获取锁,获取不到就退出,这也是synchronized没有的功能。

@Testn public void testLockTimeout() throws InterruptedException {n ReentrantLock lock = new ReentrantLock();n Thread t1 = new Thread(() -> {n try {n // 调用tryLock获取锁n if (!lock.tryLock(2, TimeUnit.SECONDS)) {n System.out.println("t1获取不到锁");n return;n }n } catch (InterruptedException e) {n System.out.println("t1被打断,获取不到锁");n return;n }n try {n System.out.println("t1获取到锁");n } finally {n lock.unlock();n }n }, "t1");n // 主线程加锁n lock.lock();n System.out.println("主线程获取到锁");nn t1.start();n Thread.sleep(3000);n try {n System.out.println("主线程释放了锁");n } finally {n lock.unlock();n }n }n复制代码

那这个原理实现是什么样的呢?

public boolean tryLock(long timeout, TimeUnit unit)n throws InterruptedException {n // 调用tryAcquireNanos方法n return sync.tryAcquireNanos(1, unit.toNanos(timeout));n}nnpublic final boolean tryAcquireNanos(int arg, long nanosTimeout) {n if (Thread.interrupted()) n throw new InterruptedException(); n // tryAcquire 尝试一次,获取不到的话调用doAcquireNanos方法n return tryAcquire(arg) || doAcquireNanos(arg, nanosTimeout);n}nnprotected final boolean tryAcquire(int acquires) { n return nonfairTryAcquire(acquires);n}n复制代码

private boolean doAcquireNanos(int arg, long nanosTimeout) { n if (nanosTimeout <= 0L)n return false;n // 获取最后期限的时间戳n final long deadline = System.nanoTime() + nanosTimeout;n // 将当前线程添加到队列中n final Node node = addWaiter(Node.EXCLUSIVE);n boolean failed = true;n try {n // 自旋n for (;;) {n // 获取前驱节点n final Node p = node.predecessor();n // 前驱节点是head,尝试获取锁n if (p == head && tryAcquire(arg)) {n setHead(node);n p.next = null; // help GCn failed = false;n return true;n }n // 计算还需等待的时间n nanosTimeout = deadline - System.nanoTime();n if (nanosTimeout <= 0L)t//时间已到 n return false;n if (shouldParkAfterFailedAcquire(p, node) &&n // 如果 nanosTimeout 大于该值,才有阻塞的意义,否则直接自旋会好点n nanosTimeout > spinForTimeoutThreshold)n LockSupport.parkNanos(this, nanosTimeout);n // 【被打断会报异常】n if (Thread.interrupted())n throw new InterruptedException();n } n }n}n复制代码

  • 如果nanosTimeout小于0,表示到了指定时间没有获取锁成功,返回false
  • 如果 nanosTimeout 大于spinForTimeoutThreshold,值为1000L,进行阻塞。因为时间太短阻塞没有意义,否则直接自旋会好点。

总结

本文主要从使用到原理讲解了ReentrantLock锁的可重入、可打断和锁超时的特性,希望对大家有帮助。

原文链接:https://juejin.cn/post/7153608875671814152