ReentrantLock源码解析

最新推荐文章于 2024-04-24 23:19:53 发布
最新推荐文章于 2024-04-24 23:19:53 发布
阅读量3.3k 收藏 1
点赞数 4
分类专栏： 并发编程 文章标签： ReentrantLock源码 CLH AQS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34125999/article/details/105371113
版权

1 数据结构

ReentrantLock是可重入锁，又分为公平锁和非公平锁。类图如下：
在这里插入图片描述

1.1 AQS源码解析

https://blog.csdn.net/qq_34125999/article/details/105343472

1.2 Sync

/**
* ReentrantLock 基础结构
*/
abstract static class Sync extends AbstractQueuedSynchronizer {
    
    private static final long serialVersionUID = -5179523762034025860L;
    
    /**
     * 抽象方法，加锁方式，由公平锁、非公平锁实现
     */
    abstract void lock();
    
    /**
     * 非公平锁获取资源
     */
    final boolean nonfairTryAcquire(int acquires) {
        //当前线程
        final Thread current = Thread.currentThread();
        //获取同步状态
        int c = getState();
        //如果状态为0，表示没有线程拥有资源
        if (c == 0) {
            //cas修改同步状态，修改成功设置获取资源的线程,返回抢占资源成功
            if (compareAndSetState(0, acquires)) {
                setExclusiveOwnerThread(current);
                return true;
            }
        }
        //如果当前线程就是持有资源的线程
        else if (current == getExclusiveOwnerThread()) {
            //同步状态增加acquires
            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) {
        //获取当前同步状态，减去释放的资源
        int c = getState() - releases;
        //判断释放资源的线程是否是当前线程
        if (Thread.currentThread() != getExclusiveOwnerThread())
            throw new IllegalMonitorStateException();
        //资源标记
        boolean free = false;
        //释放资源后，同步状态为0，那么释放成功，设置占有资源的线程为null
        if (c == 0) {
            free = true;
            setExclusiveOwnerThread(null);
        }
        //更新同步状态
        setState(c);
        //返回资源标记
        return free;
    }
    
    
    //判断当前线程是否是占有资源的线程
    protected final boolean isHeldExclusively() {
        return getExclusiveOwnerThread() == Thread.currentThread();
    }
    //创建condition
    final ConditionObject newCondition() {
        return new ConditionObject();
    }
    //获取占有资源的线程
    final Thread getOwner() {
        return getState() == 0 ? null : getExclusiveOwnerThread();
    }
    //获取同步状态
    final int getHoldCount() {
        return isHeldExclusively() ? getState() : 0;
    }
    //判断是否可以抢占资源
    final boolean isLocked() {
        return getState() != 0;
    }
    /**
     * Reconstitutes the instance from a stream (that is, deserializes it).
     */
    private void readObject(java.io.ObjectInputStream s)
        throws java.io.IOException, ClassNotFoundException {
        s.defaultReadObject();
        setState(0); // reset to unlocked state
    }
}

1.3 NonfairSync

/**
 * 非公平锁
 */
static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;
    /**
     * 加锁
     */
    final void lock() {
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            acquire(1);
    }
        
    /**
     * 尝试获取资源
     */    
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

1.4 FairSync

/**
* 公平锁
*/
static final class FairSync extends Sync {
    private static final long serialVersionUID = -3000897897090466540L;
    
    /**
     * 加锁
     */
    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;
    }

}

2 非公平锁加锁

2.1 NonfairSync lock

static final class NonfairSync extends Sync {
    private static final long serialVersionUID = 7316153563782823691L;

    /**
     * 加锁
     */
    final void lock() {
        //cas抢资源，如果同步状态是0，当前线程抢到资源，那么就不用入队，直接干活
        if (compareAndSetState(0, 1))
            setExclusiveOwnerThread(Thread.currentThread());
        else
            //获取一个资源
            acquire(1);
    }
    
    /**
     * 尝试获取资源
     */
    protected final boolean tryAcquire(int acquires) {
        return nonfairTryAcquire(acquires);
    }
}

2.2 AbstractQueuedSynchronizer acquire

public final void acquire(int arg) {
    //尝试获取资源、加入队尾巴、进入等待
    if (!tryAcquire(arg) &&
        acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
        selfInterrupt();
}

2.3 tryAcquire

(1) NonfairSync tryAcquire

protected final boolean tryAcquire(int acquires) {
   //非公平锁获取资源  
   return nonfairTryAcquire(acquires);
}

(2) Sync nonfairTryAcquire

final boolean nonfairTryAcquire(int acquires) {
    //获取当前线程
    final Thread current = Thread.currentThread();
    //获取同步状态
    int c = getState();
    //当前状态为0，代表没有线程拥有资源
    if (c == 0) {
        //cas当前线程抢占资源，抢占成功,设置抢到资源的线程,返回抢占资源成功
        if (compareAndSetState(0, acquires)) {
            setExclusiveOwnerThread(current);
            return true;
        }
    }
    //如果当前线程是拥有资源的线程
    else if (current == getExclusiveOwnerThread()) {
        //同步状态增加资源量，更新状态，返回抢占资源成功
        int nextc = c + acquires;
        if (nextc < 0) // overflow
            throw new Error("Maximum lock count exceeded");
        setState(nextc);
        return true;
    }
    //抢占资源失败
    return false;
}

2.4 AQS addWaiter(Node.EXCLUSIVE)

(1) addWaiter

/**
 * 添加等待者
 */
private Node addWaiter(Node mode) {
    //创建一个独占节点
    Node node = new Node(Thread.currentThread(), mode);
    //获取AQS队尾
    Node pred = tail;
    //如果队尾存在
    if (pred != null) {
        //当前节点的前指针指向队尾
        node.prev = pred;
        //cas快速更新队尾,(expect:队尾,update:当前节点).更新成功，更新以前队尾的后指针
        if (compareAndSetTail(pred, node)) {
            pred.next = node;
            return node;
        }
    }
    //自旋更新队尾
    enq(node);
    //返回当前节点
    return node;
}

(2) AQS enq(node)

/**
 * 自旋向CLH队列队尾插入数据
 */
private Node enq(final Node node) {
    //自旋
    for (;;) {
        //获取队尾
        Node t = tail;
        //如果队尾为空，创建CLH队列的队头、队尾
        if (t == null) { // Must initialize
            if (compareAndSetHead(new Node()))
                tail = head;
        } else {
            //当前节点的前指针指向队尾
            node.prev = t;
            //cas设置队尾,设置成功后更新队尾的后指针，返回当前节点
            if (compareAndSetTail(t, node)) {
                t.next = node;
                return t;
            }
        }
    }
}

2.5 acquireQueued(addWaiter(Node.EXCLUSIVE), arg)

(1) AQS acquireQueued

/**
 * 自旋，等待 或 成功抢占资源返回
 */
final boolean acquireQueued(final Node node, int arg) {
    //失败标记
    boolean failed = true;
    try {
        //打断标记
        boolean interrupted = false;
        //自旋
        for (;;) {
            //获取当前节点的前驱节点
            final Node p = node.predecessor();
            //如果当前节点是CLH队列第二个节点，并且抢占了资源
            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);
    }
}

(2) AQS shouldParkAfterFailedAcquire

/**
* 是否进入等待
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
    //获得当前节点前驱节点的状态
    int ws = pred.waitStatus;
    
    //如果前节点是SIGNAL状态,进入等待状态，返回true
    if (ws == Node.SIGNAL)
        return true;
    //如果前驱点解的状态是(CANCELLED),寻找有效的前驱节点
    if (ws > 0) {
        do {
            node.prev = pred = pred.prev;
        } while (pred.waitStatus > 0);
        pred.next = node;
    }
    //cas把前驱节点设置为SIGNAL状态
    else {
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
    }
    //返回false,重新进入自旋
    return false;
}

(3) AQS parkAndCheckInterrupt

/**
* 调用LockSupport进行等待(LockSupport调用的是unsafe)
*/
private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

2.6 时序图

在这里插入图片描述

3 公平锁加锁

/**
* 流程和非公平锁差不多，当一个新线程进来非公平锁有抢资源操作，如果抢到资源那么不用进入CLH队列,非公平锁必须入CLH队列
* 所以非公平锁比公平锁快
*/
final void lock() {
    acquire(1);
}

4 解锁

4.1 ReentrantLock unlock

public void unlock() {
    sync.release(1);
}

4.2 AQS release

/**
 * 释放资源
 */
public final boolean release(int arg) {
    //尝试释放资源
    if (tryRelease(arg)) {
        //获取头指针
        Node h = head;
        //如果头指针不为空，状态是非CANCELLED状态,唤醒后续有效线程
        if (h != null && h.waitStatus != 0)
            unparkSuccessor(h);
        return true;
    }
    return false;
}

(1) AQS tryRelease

protected final boolean tryRelease(int releases) {
    //计算当前同步状态
    int c = getState() - releases;
    //如果释放资源线程不是拥有资源的线程则抛出错误
    if (Thread.currentThread() != getExclusiveOwnerThread())
        throw new IllegalMonitorStateException();
    //空闲资源标记
    boolean free = false;
    //如果同步状态为0，表示当前没有线程拥有当前资源，空闲标记为true
    if (c == 0) {
        free = true;
        setExclusiveOwnerThread(null);
    }
    //更新同步状态
    setState(c);
    return free;
}

(2) AQS unparkSuccessor

/**
*唤醒等待线程
*/
private void unparkSuccessor(Node node) {
    /*
     * 当前头节点的状态
     */
    int ws = node.waitStatus;
    
    //如果头节点的状态不是初始化状态，那么cas设置头节点的状态为初始化状态
    if (ws < 0)
        compareAndSetWaitStatus(node, ws, 0);
    /*
     * 获取CLH队列第二个节点
     */
    Node s = node.next;
    
    //如果不存在第二个节点或者第二个节点为CANCELLED状态
    if (s == null || s.waitStatus > 0) {
        //s指向null
        s = null;
        //从尾部找有效节点并且赋值给s
        for (Node t = tail; t != null && t != node; t = t.prev)
            if (t.waitStatus <= 0)
                s = t;
    }
    //如果s指向节点不为null，那么唤醒s节点的线程
    if (s != null)
        LockSupport.unpark(s.thread);
}
响彻天堂丶
关注
  • 4
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
ReentrantLock源码解析（二）
12-21
1.1 AQS源码解析 https://blog.csdn.net/qq_34125999/article/details/105343472 1.2 Sync /** * ReentrantLock 基础结构 */ abstract static class Sync extends AbstractQueuedSynchronizer { private static ...
第六章 ReentrantLock源码解析2--释放锁unlock()1
08-04
第六章 ReentrantLock源码解析2--释放锁unlock()最常用的方式：//注意：通常情况下，这个会设置成一个类变量，比如说Segement中的段锁
ReentrantLock 源码解析
weixin_45278293的博客
04-24 901
ReentrantLock 实现了 Lock 接口，内部基于 AQS 实现。所以想要弄懂 ReentrantLock ，一定要先弄明白AQS。ReentrantLock 是可重入锁，同一个线程能够多次获取到同一个 ReentrantLock 锁。ReentrantLock 类采用的是 AQS 技术中的独占模式，实现了 AQS 的 3 个关键方法：tryAcquire（），tryRelease（），isHeldExclusively（）方法。
并发编程源码解析（一）ReentrantLock源码解析（超详细）
qq_33781946的博客
11-11 474
是中的一个互斥锁，它允许线程重入锁定的代码段，而不会产生死锁。它实现了Lock 接口，内部继承了(AbstractQueuedSynchronizer) 并提供了比更多的灵活性和功能，例如可中断锁、超时锁、公平锁和多条件变量。的主要作用是实现线程间的同步和互斥访问共享资源，保证数据的一致性和完整性。在锁竞争的比较激烈的情况，优先推荐使用，具体原因以后解析的时候再来详细说明。
ReenTrantLock源码解析
不争朝夕
11-28 686
可重入锁在实现上基于AQS框架，内部维护线程的state以及队列（CLH）的waitStatus,大量采用非阻塞算法，在中低量的并发上效率是非常高的。 下面分多种情况分析源码，这里只分析非公平锁。 1.简单应用，不使用条件队列 final ReentrantLock lock=new ReentrantLock(); for (int i = 0; i &lt;2; i...
锁：ReentrantLock源码解析
Jakob_Hu的博客
11-18 653
ReentrantLock源码解析1.整体架构类注释类结构构造方法2.源码解析Sync同步器1）重入性实现原理—nonfairTryAcquire方法2）释放锁—tryRelease方法公平锁—FairSync1）资源加上公平锁—lock方法2）公平锁处理逻辑—tryAcquire方法非公平锁—NonfairSync1）资源加上非公平锁—lock方法2）非公平锁处理逻辑—tryAcquire方法R...
第五章 ReentrantLock源码解析1--获得非公平锁与公平锁lock()1
08-04
第五章 ReentrantLock源码解析1--获得非公平锁与公平锁lock()最常用的方式：//注意：通常情况下，这个会设置成一个类变量，比如说Segemen
ReentrantLock源码详解--条件锁
08-25
主要介绍了ReentrantLock源码之条件锁，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，下面我们来一起学习一下吧
Java并发之ReentrantLock类源码解析
08-27
主要为大家详细介绍了Java并发系列之ReentrantLock源码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
ReentrantLock源码解析（图解AQS）
qq_34125999的博客
11-10 4317
1 同步队列（CLH） CLH队列是Craig, Landin, and Hagersten三人发明的一种基于双向链表数据结构的队列。是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程仅仅在本地变量上自旋，它不断轮询前驱的状态，假设发现前驱释放了锁就结束自旋。 JAVA中的CLH队列是原CLH队列的一个变种，线程由原来的自旋机制改为阻塞机制。 2 AQS简介 2.1 定义 (1) 全称是 AbstractQueuedSynchronizer (2) 阻塞式锁和相关的同步器工具的框架； (3) AQS用
ThreadLocal 源码解析
qq_34125999的博客
11-30 3330
1 简介 ThreadLocal是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。 2 demo ThreadLocal 作用： 人手一份。 public class ThreadLocalTest { private static ThreadLocal<Integer> threadLoca
java volatile 关键字解析
qq_34125999的博客
11-26 2498
1 volatile 特点 (1) 有序性 (2) 可见性 2 可见性 JMM中规定所有的变量都存储在主内存（Main Memory）中，每条线程都有自己的工作内存（Work Memory），线程的工作内存中保存了该线程所使用的变量的从主内存中拷贝的副本。线程对于变量的读、写都必须在工作内存中进行，而不能直接读、写主内存中的变量。同时，本线程的工作内存的变量也无法被其他线程直接访问，必须通过主内存完成。 (1) 当写一个volatile变量时，JMM会把该线程本地内存中的变量强制刷新到主内存中去。 (2
ThreadPoolExecutor 核心方法源码解析
qq_34125999的博客
12-06 742
1 线程池的优点 (1) 资源可控性：使用线程池可以避免创建大量线程而导致内存的消耗 (2) 提高响应速度：线程池地创建实际上是很消耗时间和性能的，由线程池创建好有任务就运行，提升响应速度。 (3) 便于管理：池化技术最突出的一个特点就是可以帮助我们对池子里的资源进行管理。由线程池统一分配和管理。 2 线程池的创建 执行流程： (1) 线程池中刚开始没有线程,当一个任务提交给线程池后,线程池会创建一个新线程来执行任务。 (2) 当线程数达到当线程数达到 核心线程数上限，这时再加入任务，新加的任务会被加入队列
synchronized 锁的种类及升级步骤
qq_34125999的博客
12-03 471
1 线程状态切换的代价 java的线程是映射到操作系统原生线程之上的，如果要阻塞或唤醒一个线程就需要操作系统介入，需要在户态与核心态之间切换，这种切换会消耗大量的系统资源，因为用户态与内核态都有各自专用的内存空间，专用的寄存器等，用户态切换至内核态需要传递给许多变量、参数给内核，内核也需要保护好用户态在切换时的一些寄存器值、变量等，以便内核态调用结束后切换回用户态继续工作。 在Java早期版本中，synchronized属于重量级锁，效率低下，因为监视器锁（monitor）是依赖于底层的操作系统的Mutex
Java 内存模型【JMM】
qq_34125999的博客
11-25 101
1 概念 Java内存模型(Java Memory Model，JMM)JMM主要是为了规定了线程和内存之间的一些关系。根据JMM的设计，系统存在一个主内存(Main Memory)，Java中所有变量都储存在主存中，对于所有线程都是共享的。每条线程都有自己的工作内存(Working Memory)，工作内存中保存的是主存中某些变量的拷贝，线程对所有变量的操作都是在工作内存中进行，线程之间无法相互直接访问，变量传递均需要通过主存完成。 作用： (1) 通过JMM来实现线程和主内存之间的抽象关系。 (2) 屏
keil5安装程序（包含keygen）
05-21
keil5安装程序（包含keygen）适用于单片机学习
grpcio-1.14.1-cp37-cp37m-manylinux1_i686.whl
最新发布
05-21
Python社区提供了大量的第三方库，如NumPy、Pandas和Requests，极大地丰富了Python的应用领域，从数据科学到Web开发。Python库的丰富性是Python成为最受欢迎的编程语言之一的关键原因之一。这些库不仅为初学者提供了快速入门的途径，而且为经验丰富的开发者提供了强大的工具，以高效率、高质量地完成复杂任务。例如，Matplotlib和Seaborn库在数据可视化领域内非常受欢迎，它们提供了广泛的工具和技术，可以创建高度定制化的图表和图形，帮助数据科学家和分析师在数据探索和结果展示中更有效地传达信息。
请看完ReentrantLock源码后，画出整个ReentrantLock的执行流程逻辑图
04-13
ReentrantLock是Java中的一个可重入锁，它提供了与synchronized关键字类似的功能，但更加灵活和强大。下面是ReentrantLock的执行流程逻辑图： 1. 初始化：创建一个ReentrantLock对象，并设置初始状态为未锁定状态。...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

响彻天堂丶

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值