初探 JUC 并发编程：读写锁 ReentrantReadWriteLock 原理（8000 字源码详解）

本文中会涉及到一些前面 ReentrantLock 中学到的内容，先去阅读一下我关于独占锁 ReentrantLock 的源码解析阅读起来会更加清晰。
初探 JUC 并发编程：独占锁 ReentrantLock 底层源码解析

6.4）读写锁 ReentrantReadWriteLock 原理

前面提到的 ReentrantLock 是独占锁，某个时间只有一个线程可以获取这个锁，而实际情况中会出现读多写少的情况，ReentrantLock 无法满足这个需求，所以就有了读写锁 ReentrantReadWriteLock。这个锁采用了读写分离的策略，允许多个线程同时获取读锁。

6.4.1）类图结构

在这里插入图片描述

ReentrantReadWriteLock 的类图结构如图所示，类中维护了一个 ReadLock 和 WriteLock，它们依赖 Sync 实现功能，而 Sync 继承自 AQS，也提供了公平和非公平的实现。

下面来看一下 Sync 中的属性和常用方法：

因为读写锁中维护了读锁和写锁两个状态，但是 AQS 只提供了一个 state；读写锁中巧妙的使用了 state 的高 16 位表示读状态，也就是获取到读锁的次数，使用低十六位表示写的次数。

        static final int SHARED_SHIFT   = 16; // 读锁状态单位值 65536static final int SHARED_UNIT    = (1 << SHARED_SHIFT);// 读锁的状态单位值 65536static final int MAX_COUNT      = (1 << SHARED_SHIFT) - 1;// 写锁掩码，15 个 1static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;/** 返回读锁线程数  */static int sharedCount(int c) { // c 一般为 state 的值，将值右移 16 为return c >>> SHARED_SHIFT; }/** 返回写锁的重入次数  */static int exclusiveCount(int c) { // 将值与写锁掩码做与操作return c & EXCLUSIVE_MASK; }

        // 第一个获取到读锁的线程private transient Thread firstReader = null;// 第一个获取到读锁的线程的可重入次数private transient int firstReaderHoldCount;// 记录最后一个获取到读锁的可重入次数private transient HoldCounter cachedHoldCounter;static final class HoldCounter {int count = 0;// 使用 id 而不是引用来避免垃圾保留final long tid = getThreadId(Thread.currentThread());}

其中 readHolds 是一个 ThreadLocal 变量，存放第一个获取到读线程之外的其他线程读锁的可重入次数，ThreadLocalHoldCounter 继承自 ThreadLocal。
firstReader: 这是一个线程引用，用来记录第一个获得读锁的线程。当锁从无读线程持有（即读锁计数器shareCount为0）变为有读线程持有（即读锁计数器shareCount至少为1）时，这个变量会记录下那个“第一个”读线程。

这样做主要是为了优化后续的读锁获取操作，因为一旦有线程成为了firstReader，它在再次尝试获取读锁时，可以更快地进行，因为它不需要像其他线程那样去更新或检查线程局部的HoldCounter对象。如果这个线程释放了它的所有读锁，导致读锁计数器回到0，那么firstReader会被设置为null。

而 cachedHoldCounter 是存储最后一个获取到锁的线程的 id 和 count，是为了减少在常见情况下（即最近释放锁的线程通常是最近获取锁的线程）的线程本地存储(ThreadLocal)查找开销。

        private transient ThreadLocalHoldCounter readHolds;static final class ThreadLocalHoldCounterextends ThreadLocal<HoldCounter> {public HoldCounter initialValue() {return new HoldCounter();}}

6.4.2）写锁的获取与释放

        ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();ReentrantReadWriteLock.WriteLock writeLock = readWriteLock.writeLock();

通过上面的代码获取写锁，写锁和上面的 ReentrantLock 锁都是独占可重入锁，所以方法都差不多，调用 lock 方法，可以获取锁：

        public void lock() {sync.acquire(1);}public final void acquire(int arg) {// 调用 sync 中重写的 tryAcquire 方法if (!tryAcquire(arg) &&acquireQueued(addWaiter(Node.EXCLUSIVE), arg))selfInterrupt();}

其中调用了 WriteLock 中重写的 tryAcquire 方法：

        protected final boolean tryAcquire(int acquires) {Thread current = Thread.currentThread();int c = getState();int w = exclusiveCount(c); // 获取写锁的重入次数// 1）读锁或者写锁被占有if (c != 0) {// 1）写锁的重入次数为 0，也就是被读锁占有的情况，如果读锁占有，则 w 不为 0// 2）当前线程不是持有写锁的线程if (w == 0 || current != getExclusiveOwnerThread())return false;// 1）越界的情况// 2）如果能走到这里，说明锁被当前线程持有if (w + exclusiveCount(acquires) > MAX_COUNT)throw new Error("Maximum lock count exceeded");// 重入次数加一setState(c + acquires);return true;}// 这个 writerShouldBlock() 方法是 ReentrantReadWriteLock 中的一个抽象方法，// 用于确定当前线程在尝试获取写锁时是否应该被阻塞，// 具体是因为什么原因阻塞取决于锁的实现和其策略，如果是非公平锁不需要阻塞// 非公平锁有阻塞相关的逻辑if (writerShouldBlock() ||!compareAndSetState(c, c + acquires))return false;setExclusiveOwnerThread(current);return true;

上面的方法是写锁中实现的 tryAcquire 方法，方法的执行流程是这样的：首先回去判断状态值是否不等于 0，如果不等于零则说明读锁或者写锁被占有（读锁和写锁不能同时起作用），然后去判断写锁的重入次数是否为 0，如果为 0 则说明当前锁是读锁，无法获取写锁；如果当前锁是写锁的话，去判断锁是否被线程持有，如果被持有，对重入次数做一个自增；如果当前锁没有被占有，则将修改低 16 位的 state 来表明当前锁是写锁状态，且写锁被占有。

和 ReentrantLock 相同，方法中也提供了 lockInterruptibly() 方法、 tryLock() 方法、 tryLock(long timeout, TimeUnit unit) 作用和 ReentarntLock 完全相同，这里不赘述了。

写锁的释放方法是委托给 Sync 类来做的：

    public void unlock() {sync.release(1);}public final boolean release(int arg) {if (tryRelease(arg)) {Node h = head;if (h != null && h.waitStatus != 0)unparkSuccessor(h);return true;}return false;}

下面来看核心代码 tryRelease 的实现：

        protected final boolean tryRelease(int releases) {// 1）锁未被当前线程持有if (!isHeldExclusively())throw new IllegalMonitorStateException();int nextc = getState() - releases; // 下次修改的值boolean free = exclusiveCount(nextc) == 0; // 如果为 0 则完全释放锁if (free)setExclusiveOwnerThread(null); // 清除持有锁的线程setState(nextc);return free; // 锁是否被线程持有}

6.4.3）读锁的获取与释放

如果当前没有其他线程持有写锁，则当前线程可以获取读锁，AQS 的状态值 state 的高 16 位会增加 1，如果有线程持有写锁的话，获取读锁的线程会被阻塞。

先来看读锁的 lock 方法，同样是委托给 sync 进行的：

    public void lock() {sync.acquireShared(1);}public final void acquireShared(int arg) {if (tryAcquireShared(arg) < 0)doAcquireShared(arg);}

接下来看一下在读锁中实现的核心代码， tryAcquireShared()

        protected final int tryAcquireShared(int unused) {Thread current = Thread.currentThread();int c = getState();// 1）写锁被占有// 2）写锁不被当前线程持有if (exclusiveCount(c) != 0 &&getExclusiveOwnerThread() != current)return -1;// 获取高 16 位的内容int r = sharedCount(c);// 判断获取读锁的时候是否需要被阻塞// 1）本类中的逻辑为判断 AQS 队列中的第一个元素是否在获取写锁// 2）共享锁的获取次数没有达到上限// 3）当前线程修改 sharedCount 成功// 多个线程调用该方法的时候只要一个线程会成功（因为进行 CAS 操作），// 未成功的线程会进入 fullTryAcquireShared 方法if (!readerShouldBlock() &&r < MAX_COUNT &&compareAndSetState(c, c + SHARED_UNIT)) {// 1）没有线程获取到读锁if (r == 0) {firstReader = current;firstReaderHoldCount = 1;// 1）当前线程是第一个获取到读锁的线程} else if (firstReader == current) {firstReaderHoldCount++;} else {HoldCounter rh = cachedHoldCounter; // 最后一个获取到读锁的线程// 1）最后一个获取到读锁的线程为 null// 2）最后一个获取到锁的线程不是当前线程if (rh == null || rh.tid != getThreadId(current))// 将 cachedHoldCounter 设置为当前线程cachedHoldCounter = rh = readHolds.get();// 1）最后一个获取到锁的线程为当前线程else if (rh.count == 0)// 确保 readHolds 被初始化readHolds.set(rh);rh.count++;}return 1;}return fullTryAcquireShared(current);}

上面的代码中首先检查是否有其他线程获取到了写锁，如果有则直接返回 -1，之后会将当前线程放到 AQS 阻塞队列。如果当前获取读锁的线程持有写锁，则可以直接获取读锁，但注意释放锁的时候将两个锁都释放掉。

本类中的 readerShouldBlock() 方法是这样的：

	  // 避免重复获取读锁导致写锁无法被获取的情况final boolean readerShouldBlock() {return apparentlyFirstQueuedIsExclusive();}// 当前 AQS 队列中收个节点请求的是写锁final boolean apparentlyFirstQueuedIsExclusive() {Node h, s;return (h = head) != null &&(s = h.next)  != null &&!s.isShared()         &&s.thread != null;}

当多次获取读锁可能会导致写锁持续被阻塞，所以当发现 AQS 队列中首个节点请求的是写锁的时候，获取读锁的线程暂时阻塞给写锁让步。

因为多个线程只有一个会获取写锁，剩余的情况在 tryAcquireShared() 中并没有被处理

  1. 有线程获取写锁的时候，被阻塞
  2. CAS 操作失败

这时候就调用 fullTryAcquireShared，这个方法会循环自旋的获取读锁：

        final int fullTryAcquireShared(Thread current) {HoldCounter rh = null;for (;;) {int c = getState();// 1）写锁被占有if (exclusiveCount(c) != 0) {// 1）写锁不被当前线程持有if (getExclusiveOwnerThread() != current)return -1;// 1）当前线程应该被阻塞} else if (readerShouldBlock()) {if (firstReader == current) {// assert firstReaderHoldCount > 0;} else {if (rh == null) {rh = cachedHoldCounter;// 1）最后一个获取读锁的线程为空// 或者// 2）最后一个获取到锁的线程未被设置为本线程if (rh == null || rh.tid != getThreadId(current)) {// 判断当前线程是否获取过锁rh = readHolds.get();if (rh.count == 0)// 未获取过的话，清除 readHoldsreadHolds.remove();}}// 当前线程被阻塞了if (rh.count == 0)return -1;}}// 执行到这里说明写锁没有被占有，且当前线程没有被阻塞，可以尝试获取锁if (sharedCount(c) == MAX_COUNT)// 越界的情况throw new Error("Maximum lock count exceeded");// 使用 CAS 操作修改 state，给获取读锁的线程数加一if (compareAndSetState(c, c + SHARED_UNIT)) {// 如果当前锁没有被线程占用if (sharedCount(c) == 0) {firstReader = current;firstReaderHoldCount = 1;// 第一个持有锁的线程为当前线程} else if (firstReader == current) {firstReaderHoldCount++;} else {if (rh == null)rh = cachedHoldCounter;// cachedHoldCounter 为空，或不为当前线程if (rh == null || rh.tid != getThreadId(current))rh = readHolds.get(); // 设置 rhelse if (rh.count == 0)readHolds.set(rh);rh.count++; // 自增cachedHoldCounter = rh; // cache for release}return 1;}}}

上面的方法中，先去判断写锁有没有被占有，如果被占有则直接返回 -1。

然后去判断当前线程是否应该被阻塞，也就是 AQS 队列的队头是不是请求的写锁，然后去判断最后一个获取到锁的线程是不是本线程，如果不是的话，检查线程中的 readHolds 是否为 0（如果为 0 则说明没有获取到锁，如果获取到了锁这里应该置为 1），因为 get 方法会向线程的 ThreadLocal 中添加对象，所以在确定它没有得到锁之后清楚 ThreadLocal 中的内容。

如果上面的代码均通过，说明写锁没有被占有，且当前线程没有被阻塞，可以尝试获取锁，其中获取锁的方法和上面相同。

同样的，读锁中也存在 tryLock 等方法，这里不做过多赘述。

然后来看释放锁的方法，这里的释放锁也是委托给 Sync 类进行的：

    public void unlock() {sync.releaseShared(1);}public final boolean releaseShared(int arg) {if (tryReleaseShared(arg)) {doReleaseShared();return true;}return false;}

其中核心方法是 Sync 的实现类中实现的 tryReleaseShared 方法：

        protected final boolean tryReleaseShared(int unused) {Thread current = Thread.currentThread();// 1）当前线程是第一个获取到读锁的线程if (firstReader == current) {if (firstReaderHoldCount == 1)firstReader = null;elsefirstReaderHoldCount--;} else {HoldCounter rh = cachedHoldCounter;// 1）当前线程不是最后一个获取到锁的线程if (rh == null || rh.tid != getThreadId(current))rh = readHolds.get();// 检查重入次数int count = rh.count;// 1）锁已经释放完成，可以清除了if (count <= 1) {readHolds.remove();// 如果是 0 表示未获取到锁if (count <= 0)throw unmatchedUnlockException();}--rh.count;}// 减少一次重入次数for (;;) {int c = getState();int nextc = c - SHARED_UNIT;if (compareAndSetState(c, nextc))return nextc == 0;}}

方法中先对线程是否为 firstReader 或者 cachedHoldCounter 做了判断，对其进行特殊的处理，然后检查重入的次数，如果次数小于等于一，则本次释放就将线程持有的读锁全部释放完成，此时删除线程 ThreadLocal 中的内容；最后循环减少可重入次数。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/686009.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

JUC下CountDownLatch详解

JUC下CountDownLatch详解

详细介绍 CountDownLatch是Java并发包java.util.concurrent中提供的一个同步工具类&#xff0c;它允许一个或多个线程等待其他线程完成操作后再继续执行。这个工具类基于一个计数器&#xff0c;计数器的初始值可以由构造函数设定。线程调用countDown()方法会将计数器减1&#x…
阅读更多...
drawio 网页版二次开发（2）：开始修改代码

drawio 网页版二次开发（2）：开始修改代码

目录 一 说明 二 打开开发环境 1. 代码调整 2. 修改访问链接 3. 注意 三 部分功能的代码汇总 1. 保存功能 2. 菜单栏折叠按钮功能 3. 顶部菜单栏 4.在顶部菜单栏中的【文件】菜单中新增选项 &#xff08;1&#xff09; 方法一&#xff1a;单独增加 &#xff08;…
阅读更多...
C++动态内存管理：与C语言动态内存管理的差异之争

C++动态内存管理：与C语言动态内存管理的差异之争

当你改错一行代码的时候&#xff1a; 当你想要重构别人的代码时&#xff1a; 目录 前言 一、C/C的内存分布 二、C/C语言中的动态内存管理 三、new与delete的实现原理 总结&#xff1a; 前言 在C中&#xff0c;内存管理是一个至关重要的主题。正确地管理内存可以避免内存泄…
阅读更多...
SparkSQL编程入口和模型与SparkSQL基本编程

SparkSQL编程入口和模型与SparkSQL基本编程

SparkSQL编程入口和模型 SparkSQL编程模型 主要通过两种方式操作SparkSQL&#xff0c;一种就是SQL&#xff0c;另一种为DataFrame和Dataset。 1)SQL&#xff1a;SQL不用多说&#xff0c;就和Hive操作一样&#xff0c;但是需要清楚一点的是&#xff0c;SQL操作的是表&#xf…
阅读更多...
百面算法工程师 | 模型评价指标及优化策略

百面算法工程师 | 模型评价指标及优化策略

本文给大家带来的百面算法工程师是深度学习模型评价指标的面试总结&#xff0c;文章内总结了常见的提问问题&#xff0c;旨在为广大学子模拟出更贴合实际的面试问答场景。在这篇文章中&#xff0c;我们还将介绍一些常见的评价方案&#xff0c;并提供参考的回答及其理论基础&…
阅读更多...
程序的环境和预处理#define #ifdefine

程序的环境和预处理#define #ifdefine

文章目录 预编译 预处理做的事情把#include<>里面的内容执行了注释删除&#xff0c;使用空格替换注释define 把符号统统替换为值 编译阶段做的事情链接做的事情运行环境预处理(预处理)详解预定义符号__FILE____LINE____DATE__ __TIME__写日志文件__FUNCTION__ #define预处…
阅读更多...
Java解决垂直鉴权问题（对垂直权限进行校验）

Java解决垂直鉴权问题（对垂直权限进行校验）

Java解决垂直鉴权问题&#xff08;对垂直权限进行校验&#xff09; 文章目录 Java解决垂直鉴权问题&#xff08;对垂直权限进行校验&#xff09;前言一、垂直鉴权是什么&#xff1f;二、实现过程1.新建接口权限菜单映射表2.项目初始化时加载接口菜单映射关系3.自定义过滤器拦截…
阅读更多...
Amazon SQS使用

Amazon SQS使用

Amazon SQS 服务(Amazon Simple Queue Service)。Amazon SQS 允许生产器向队列发送消息。然后&#xff0c;消息会存储在 SQS 队列中。当使用者准备好处理新消息时&#xff0c;使用者可以从队列中轮询这些消息。应用程序、微服务和多个 AWS 服务可以担当生产器或使用者的角色。 …
阅读更多...
重生我是嵌入式大能之串口调试UART

重生我是嵌入式大能之串口调试UART

什么是串口 串口是一种在数据通讯中广泛使用的通讯接口&#xff0c;通常我们叫做UART (通用异步收发传输器Universal Asynchronous Receiver/Transmitter)&#xff0c;其具有数据传输速度稳定、可靠性高、适用范围广等优点。在嵌入式系统中&#xff0c;串口常用于与外部设备进…
阅读更多...
C++内存分区

C++内存分区

代码区&#xff1a;存放函数体的二进制代码&#xff0c;由操作系统进行管理的 全局区&#xff1a;存放全局变量和静态变量以及常量 栈区&#xff1a;由编译器自动分配释放&#xff0c;存放函数的参数值&#xff0c;局部变量等 堆区&#xff1a;由程序员分配和释放&#xff0c;若…
阅读更多...
【数据结构与算法】常见的排序算法

【数据结构与算法】常见的排序算法

文章目录 排序的概念冒泡排序&#xff08;Bubble Sort&#xff09;插入排序&#xff08;Insert Sort&#xff09;选择排序&#xff08;Select Sort&#xff09;希尔排序&#xff08;Shell Sort&#xff09;写法一写法二 快速排序&#xff08;Quick Sort&#xff09;hoare版本&a…
阅读更多...
鸿蒙内核源码分析(文件句柄篇) | 你为什么叫句柄

鸿蒙内核源码分析(文件句柄篇) | 你为什么叫句柄

句柄 | handle int open(const char* pathname,int flags); ssize_t read(int fd, void *buf, size_t count); ssize_t write(int fd, const void *buf, size_t count); int close(int fd);只要写过应用程序代码操作过文件不会陌生这几个函数,文件操作的几个关键步骤嘛,跟把大…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023