ReentrantLock 原理及源码剖析

于 2021-05-05 22:32:58 发布
阅读量120 收藏
点赞数 2
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46144481/article/details/116431015
版权

首先看看ReentrantLock 的UML类图

ReentrantLock 的UML类图

1. 非公平锁实现原理

1.1 加锁解锁流程

从构造器看，ReentrantLock 默认实现为非公平锁

public ReentrantLock() {
    sync = new NonfairSync();
}

NonfairSync 继承自 AQS

  • 没有竞争时

没有竞争时

static final class NonfairSync extends Sync {

    final void lock() {
    	//没有竞争时，将锁的状态从0改为1，成功则设置锁的owner为当前线程，失败则
    	//进入else块
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }

    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

  • 第一个竞争出现时

第一个竞争出现时
进入acquire(1)

public final void acquire(int arg) {
    if (!tryAcquire(arg) &&
        //下面的语句的意思是创建一个节点对象加入到队列里面去
        //addWaiter流程：
        //1.如果tail不为空，则将node设置为tail并返回node
        //2.如果tail为空，则初始化tail，同上将node设置为tail并返回node
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

===========================addWaiter代码如下===========================
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;
}
=====================================================================
private Node enq(final Node node) {
    for (;;) {
        Node t = tail;
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            node.prev = t;
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}
  • Thread-1 执行了
  1. CAS 尝试将 state 由 0 改为 1，结果失败
  2. 进入 tryAcquire 逻辑，这时 state 已经是1，结果仍然失败
  3. 接下来进入 addWaiter 逻辑，构造 Node 队列
    • 图中黄色三角表示该 Node 的 waitStatus 状态，其中 0 为默认正常状态
    • Node 的创建是懒惰的
    • 其中第一个 Node 称为 Dummy（哑元）或哨兵，用来占位，并不关联线程
      在这里插入图片描述
  • 当前线程进入 acquireQueued 逻辑
  1. acquireQueued 会在一个死循环中不断尝试获得锁，失败后进入 park 阻塞
  2. 如果自己是紧邻着 head（排第二位），那么再次 tryAcquire 尝试获取锁，当然这时 state 仍为 1，失败
  3. 进入 shouldParkAfterFailedAcquire 逻辑，将前驱 node，即 head 的 waitStatus 改为 -1（-1的意思是，该节点由责任去唤醒下一个节点），这次返回 false

在这里插入图片描述

final boolean acquireQueued(final Node node, int arg) {
    boolean failed = true;
    try {
        boolean interrupted = false;
        for (;;) {
            //获取前驱节点
            final Node p = node.predecessor();
            //如果前驱节点为head意味着该节点处于第二位，还有机会获得锁
            if (p == head && tryAcquire(arg)) {
                //当获取锁成功后，设置当前node为head
                setHead(node);
                p.next = null; // help GC
                failed = false;
                return interrupted;
            }
            //shouldParkAfterFailedAcquire()意思是获取锁失败后是否要阻塞
            //如果该方法返回真，则调用parkAndCheckInterrupt()阻塞住
            //返回假的话则继续做下一轮的循环
            if (shouldParkAfterFailedAcquire(p, node) &&
                //当锁释放开后，该线程被unpark唤醒，然后设置interrupted为
                //true，并继续执行循环
                parkAndCheckInterrupt())
                interrupted = true;
        }
    } finally {
        if (failed)
            cancelAcquire(node);
    }
}
  1. shouldParkAfterFailedAcquire 执行完毕回到 acquireQueued ，再次 tryAcquire 尝试获取锁，当然这时state 仍为 1，失败
  2. 当再次进入 shouldParkAfterFailedAcquire 时，这时因为其前驱 node 的 waitStatus 已经是 -1，这次返回true
  3. 进入 parkAndCheckInterrupt， Thread-1 park（灰色表示）
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    int ws = pred.waitStatus;
    //前驱节点状态已经是-1
    if (ws == Node.SIGNAL)
        return true;
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    } else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    return false;
}
============================================================
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}
  • 再次有多个线程经历上述过程竞争失败，变成这个样子
    在这里插入图片描述
  • Thread-0 释放锁，进入 tryRelease 流程，如果成功
  1. 设置 exclusiveOwnerThread 为 null
  2. state = 0
    在这里插入图片描述
  • 当前队列不为 null，并且 head 的 waitStatus = -1，进入 unparkSuccessor 流程，
    找到队列中离 head 最近的一个 Node（没取消的），unpark 恢复其运行，本例中即为 Thread-1
    回到 Thread-1 的 acquireQueued 流程
    在这里插入图片描述
public void unlock() {
    sync.release(1);
}
=============================================================
public final boolean release(int arg) {
    if (tryRelease(arg)) {
        Node h = head;
        //head不为空且状态不为0（即-1）
        if (h != null && h.waitStatus != 0)
            //唤醒后继节点(离head最近的一个没取消的node，unpark恢复其运行)
            unparkSuccessor(h);
        return true;
    }
    return false;
}
=============================================================
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;
        //设置owner为null
        setExclusiveOwnerThread(null);
    }
    //设置状态为0
    setState(c);
    return free;
}
=============================================================
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);
}
  • 如果加锁成功（没有竞争），会设置
  1. exclusiveOwnerThread 为 Thread-1，state = 1
  2. head 指向刚刚 Thread-1 所在的 Node，该 Node 清空 Thread
  3. 原本的 head 因为从链表断开，而可被垃圾回收
  • 如果这时候有其它线程来竞争（非公平的体现），例如这时有 Thread-4 来了
    在这里插入图片描述
  • 如果不巧又被 Thread-4 占了先
  1. Thread-4 被设置为 exclusiveOwnerThread，state = 1
  2. Thread-1 再次进入 acquireQueued 流程，获取锁失败，重新进入 park 阻塞

1.2 可重入原理

static final class NonfairSync extends Sync {

    final boolean nonfairTryAcquire(int acquires) {
        final Thread current = Thread.currentThread();
        int c = getState();
        if (c == 0) {
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        // 如果已经获得了锁, 线程还是当前线程, 表示发生了锁重入
        else if (current == getExclusiveOwnerThread()) {
        // state++
            int nextc = c + acquires;
            if (nextc < 0) // overflow
                throw new Error("Maximum lock count exceeded");
            setState(nextc);
            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;
        // 支持锁重入, 只有 state 减为 0, 才释放成功
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        setState(c);
        return free;
    }
}

1.3 可打断模式

  • 不可打断模式

在此模式下，即使它被打断，仍会驻留在 AQS 队列中，一直要等到获得锁后方能得知自己被打断了

// Sync 继承自 AQS
static final class NonfairSync extends Sync {
    // ...
    private final boolean parkAndCheckInterrupt() {
        // 如果打断标记已经是 true, 则 park 会失效
        LockSupport.park(this);
        // interrupted 会清除打断标记
        return Thread.interrupted();
    }
    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;
                    failed = false;
                    // 还是需要获得锁后, 才能返回打断状态
                    return interrupted;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt()) {
                    // 如果是因为 interrupt 被唤醒, 返回打断状态为 true
                    interrupted = true;
                }
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) {
            // 如果打断状态为 true
            selfInterrupt();
        }
    }
    static void selfInterrupt() {
        // 重新产生一次中断
        Thread.currentThread().interrupt();
    }
}

  • 可打断模式

static final class NonfairSync extends Sync {
    public final void acquireInterruptibly(int arg) throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        // 如果没有获得到锁, 进入 ㈠
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }
    // ㈠ 可打断的获取锁流程
    private void doAcquireInterruptibly(int arg) throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                parkAndCheckInterrupt()) {
                    // 在 park 过程中如果被 interrupt 会进入此
                    // 这时候抛出异常, 而不会再次进入循环
                    throw new InterruptedException();
                }
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
}

2.公平锁实现原理

// 与非公平锁主要区别在于 tryAcquire 方法的实现
protected final boolean tryAcquire(int acquires) {
    final Thread current = Thread.currentThread();
    int c = getState();
    if (c == 0) {
        // 先检查 AQS 队列中是否有前驱节点, 没有才去竞争
        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;
}

3.条件变量实现原理

  • 3.1 await 流程

public final void await() throws InterruptedException {
    if (Thread.interrupted())
        throw new InterruptedException();
    //加入condition队列中    
    Node node = addConditionWaiter();
    //释放锁
    int savedState = fullyRelease(node);
    int interruptMode = 0;
    while (!isOnSyncQueue(node)) {
        //将该线程park住
        LockSupport.park(this);
        if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
            break;
    }
    if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
        interruptMode = REINTERRUPT;
    if (node.nextWaiter != null) // clean up if cancelled
        unlinkCancelledWaiters();
    if (interruptMode != 0)
        reportInterruptAfterWait(interruptMode);
}
  1. 开始 Thread-0 持有锁，调用 await，进入 ConditionObject 的 addConditionWaiter 流程
    创建新的 Node 状态为 -2（Node.CONDITION），关联 Thread-0，加入等待队列尾部
    在这里插入图片描述
private Node addConditionWaiter() {
    Node t = lastWaiter;
    // If lastWaiter is cancelled, clean out.
    if (t != null && t.waitStatus != Node.CONDITION) {
        unlinkCancelledWaiters();
        t = lastWaiter;
    }
    Node node = new Node(Thread.currentThread(), Node.CONDITION);
    if (t == null)
        firstWaiter = node;
    else
        t.nextWaiter = node;
    lastWaiter = node;
    return node;
}
  1. 接下来进入 AQS 的 fullyRelease 流程，释放同步器上的锁
    在这里插入图片描述
final int fullyRelease(Node node) {
    boolean failed = true;
    try {
        int savedState = getState();
        if (release(savedState)) {
            failed = false;
            return savedState;
        } else {
            throw new IllegalMonitorStateException();
        }
    } finally {
        if (failed)
            node.waitStatus = Node.CANCELLED;
    }
}
  1. unpark AQS 队列中的下一个节点，竞争锁，假设没有其他竞争线程，那么 Thread-1 竞争成功在这里插入图片描述

  • 3.2 signal 流程

public final void signal() {
    //首先检查调用该方法的线程是不是锁的持有者
    if (!isHeldExclusively())
        throw new IllegalMonitorStateException();
    Node first = firstWaiter;
    if (first != null)
        doSignal(first);
}

  1. 假设 Thread-1 要来唤醒 Thread-0
    在这里插入图片描述

  2. 进入 ConditionObject 的 doSignal 流程，取得等待队列中第一个 Node，即 Thread-0 所在 Node

private void doSignal(Node first) {
    do {
        //如果firstWaiter的下一个节点为null，则说明该队列只有一个node
        //并使lastWaiter也设置为null
        if ( (firstWaiter = first.nextWaiter) == null)
            lastWaiter = null;
        first.nextWaiter = null;
    } while (
    //将该节点加入到aqs尾部（等待队列），成功返回true，且不继续向下执行
    !transferForSignal(first) &&
             //失败后将寻找下一个节点，若下一个节点存在则唤醒下一个节点
             (first = firstWaiter) != null);
}

在这里插入图片描述

  1. 执行 transferForSignal 流程，将该 Node 加入 AQS 队列尾部，将 Thread-0 的 waitStatus 改为 0，Thread-3 的waitStatus 改为 -1
final boolean transferForSignal(Node node) {
    // 将节点的状态由-2改成0（因为在aqs队列里最后一个元素的状态是0）
    if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
        return false;
     //插入的队列后返回该节点的前驱节点
    Node p = enq(node);
    int ws = p.waitStatus;
    //当前驱节点的状态大于0时，表示该节点被取消
    //或当设置前驱节点状态失败时，则unpark该线程，否则返回true
    if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
        LockSupport.unpark(node.thread);
    return true;
}

在这里插入图片描述
7. Thread-1 释放锁，进入 unlock 流程

jvav萌新
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ReentrantLock的实现原理
盛夏温暖流年
09-30 4300
ReentrantLock 简介 ReentrantLock 实现了 Lock 接口，是一种可重入的独占锁。 相比于 synchronized 同步锁，ReentrantLock 更加灵活，拥有更加强大的功能，比如可以实现公平锁机制。 首先，先来了解一下什么是公平锁机制。 ReentrantLock 的公平锁机制 我们知道，ReentrantLock 分为公平锁和非公平锁，可以通过构造方法来指定具体类型： //默认非公平锁 public ReentrantLock() { sync =
Java并发包源码分析(JDK1.8)
06-13
Java并发包源码分析(JDK1.8)：囊括了java.util.concurrent包中大部分类的源码分析，其中涉及automic包，locks包...对每个类的核心源码进行详细分析，笔记详细，由浅入深，层层深入，带您剖析并发编程原理
ReentrantLock的await/signal机制源码学习
我是兴锅的博客
08-29 2108
测试代码如下： public class ConditionTest { static ReentrantLock lock = new ReentrantLock(); //创建锁对象 static Condition condition = lock.newCondition(); //创建条件变量 public static void main(Str...
ReentrantLock实现原理
weixin_30606461的博客
09-17 248
1 synchronized和lock 1.1synchronized的局限性 　　synchronized是java内置的关键字，它提供了一种独占的加锁方式。synchronized的获取和释放锁有JVM实现，用户不需要显式的释放锁，非常方便，然而synchronized也有一定的局限性，例如： 　　1、当线程尝试获取锁的时候，如果获取不到锁就会一直阻塞。 　　2、如果获取锁的线程进入...
并发多线程之Lock及ReentrantLock源码剖析
binga的博客
10-31 327
目录Lock及ReentrantLock提供的功能Lock接口提供的方法ReentrantLock的实现 在并发多线程之AQS源码分析（上）和并发多线程之AQS源码分析（下）已经对JUC中的AQS源码进行了剖析梳理，AQS可以说是juc包下所有工具的基础框架，其提供了两种队列：同步队列和条件队列。并且控制了资源的获取和释放，以及线程的阻塞和唤醒调度。那么接下来就是学习一下juc包下各个工具是怎么基于AQS来实现的，这里先从Lock及其实现类ReentrantLock开始。关于Lock及ReentrantLo
juc源码视频教程最全
05-22
"juc源码视频教程"将引导你逐层剖析这些组件的内部工作原理，让你在实践中更好地运用并发编程技术。 本视频教程可能包含如下内容： 1. JUC组件的设计理念和使用场景。 2. 深入分析ExecutorService的工作流程和...
java源码：copass源代码.rar
10-13
《Java源码剖析：Copass框架深度解析》 在IT领域，源码是理解软件运行机制最直接的方式，尤其对于开发者来说，阅读优秀的源码能够提升编程技能，洞悉设计思想。今天，我们来深入探讨Java领域的Copass框架源码，以期...
Java互联网架构多线程并发编程原理及实战 视频教程 下载.zip
06-18
4-5 深入剖析ReentrantLock源码之非公平锁的实现.mp4 4-6 深入剖析ReentrantLock源码之公平锁的实现.mp4 4-7 掌控线程执行顺序之多线程debug.mp4 4-8 读写锁特性及ReentrantReadWriteLock的使用.mp4 4-9 源码...
Java互联网架构多线程并发编程原理及实战 视频教程 下载3.zip
最新发布
06-18
4-5 深入剖析ReentrantLock源码之非公平锁的实现.mp4 4-6 深入剖析ReentrantLock源码之公平锁的实现.mp4 4-7 掌控线程执行顺序之多线程debug.mp4 4-8 读写锁特性及ReentrantReadWriteLock的使用.mp4 4-9 源码...
join(),ReentrantLock结合Condition的await(),signal()的使用
啊呆的博客
12-04 440
1.join的使用点击打开链接 2.Condition的使用点击打开链接
java lock signal方法_java多线程系列(四)---ReentrantLock的使用详解
weixin_36173545的博客
02-13 454
Lock的使用前言：本系列将从零开始讲解java多线程相关的技术，内容参考于《java多线程核心技术》与《java并发编程实战》等相关资料，希望站在巨人的肩膀上,再通过我的理解能让知识更加简单易懂。ReentrantLocak特性(对比synchronized)尝试获得锁获取到锁的线程能够响应中断ReentrantLock(重入锁)publicclassMyService{privateL...
码农小汪-ReentrantLock-lock方法
汪小哥
04-03 2418
我们知道，ReentrantLock有公平锁和不公平锁区分，我们首先来看一下，继承图简单了解哈。 public class ReentrantLock implements Lock, java.io.Serializable private final Sync sync; /** * Base of synchronization control for thi
关于Java同步锁中await和signalAll的使用经验
炭烧生豪的技术空间
06-04 1万+
当使用Lock来保证线程同步时，需使用Condition对象来使线程保持协调。Condition实例被绑定在一个Lock的对象上，使用Lock对象的方法newCondition()获取Condition的实例。Condition提供了下面三种方法，来协调不同线程的同步： 1、await()：导致当前线程等待，直到其他线程调用该Condition的signal()或signalAll()方法唤醒该
ReentrantLock 原理
weixin_45359574的博客
03-23 220
ReentrantLock 原理非公平锁实现原理加锁流程解锁流程 ReentrantLock 主要是通过 AQS + CAS 的方式实现加锁和解锁原理。 这里先说一下重要的几个属性。 state 标记是否加锁成功或是否发生锁重入 exclusiveOwnerThread 当前拥有锁的线程 waitStatus 线程等待状态 CANCELLED 值为1，表示取消获取锁，会被从队列中删除 SIGNAL 值为-1，表示等待队列中的下一个线程需被阻塞 CONDITION 值为-2，表示当前线程等待被唤醒 PRO
Java并发编程之ReentrantLock详解
Stay Hungry, Stay Foolish
05-31 2万+
---
ReentrantLock实现原理及源码分析
augfun的博客
02-24 1393
ReentrantLock是Java并发包中提供的一个可重入的互斥锁。ReentrantLock和synchronized在基本用法，行为语义上都是类似的，同样都具有可重入性。只不过相比原生的Synchronized，ReentrantLock增加了一些高级的扩展功能，比如它可以实现公平锁，同时也可以绑定多个Conditon。 可重入性/公平锁/非公平锁 　　可重入性 　　　　所谓的可重入性，就是可以支持一个线程对锁的重复获取，原生的synchronized就具有可重入性，一个用synchronize
ReentrantLock的lock-unlock流程详解
热门推荐
luonanqin的专栏
12-11 2万+
在jdk1.5之前，多线程之间的同步是依靠synchronized来实现。synchronized是java的关键字，直接由jvm解释成为指令进行线程同步管理。因为操作简单，而且现在jdk的后续版本已经对synchronized进行了很多的优化，所以一直是大家编写多线程程序常用的同步工具。那为什么要推出新的同步api呢？jdk1.5发布的时候，synchronized性能并不好，这可能是concurrent包出现的一个潜在原因，但是更重要的是新的api提供了更灵活，更细粒度的同步操作，以满足不同的需求。但是
7-ReentrantLock底层原理分析
weixin_45596022的博客
02-15 6918
一，Lock Lock 在 J.U.C 中是最核心的组件。 1，Lock实现 Lock 本质上是一个接口，它定义了释放锁和获得锁的抽象方法，定义成接口就意味着它定义了锁的一个标准规范，也同时意味着锁的不同实现。实现 Lock 接口的类有很多，以下为几个常见的锁实现。 ReentrantLock：表示重入锁，它是唯一一个实现了 Lock 接口的类。重入锁指的是线程在获得锁之后，再次获取该锁不需要阻塞，而是直接关联一次计数器增加重入次数。 ReentrantReadWriteLock：重入读写锁，它实现了 Re
ReentrantLock原理讲解
08-06
ReentrantLock的原理主要包含以下几个方面： 1. 线程控制：ReentrantLock内部维护了一个线程的等待队列，每个线程通过调用lock()方法来竞争锁资源。当一个线程成功获取到锁资源时，其他线程会被阻塞在等待队列中，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值