java并发-ReentrantReadWriteLock读写锁

news/2024/7/7 23:17:07

文章目录

  • 介绍
  • 读写锁的获取规则
  • 示例
  • 源码解读
    • ReentrantReadWriteLock核心变量
    • ReentrantReadWriteLock相关属性和构造函数
    • Sync静态内部类的核心属性
    • tryAcquireShared方法
    • tryAcquire方法
    • 锁降级
  • 总结

介绍

读写锁就是将一个锁拆分为读锁和写锁两个锁。

读写锁的获取规则

  • 如果有一个线程已经占用了读锁，则此时其他线程如果要申请读锁，可以申请成功。
  • 如果有一个线程已经占用了读锁，则此时其他线程如果要申请写锁，则申请写锁的线程会一直等待 释放读锁，因为读写不能同时操作。
  • 如果有一个线程已经占用了写锁，则此时其他线程如果申请写锁或者读锁，都必须等待之前的线程 释放写锁，同样也因为读写不能同时，并且两个线程不应该同时写。

总之，要么是一个或多个线程同时有读锁，要么是一个线程有写锁，但是两者不会同 时出现。也可以总结为：读读共享、其他都互斥（写写互斥、读写互斥、写读互斥）。

示例

public class ReadWriteLockDemo {
    private static final ReentrantReadWriteLock reentrantReadWriteLock = new
    ReentrantReadWriteLock(false);
    private static final ReentrantReadWriteLock.ReadLock readLock =
    reentrantReadWriteLock
    .readLock();
    private static final ReentrantReadWriteLock.WriteLock writeLock =
    reentrantReadWriteLock
    .writeLock();
    private static void read() {
        readLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "得到读锁，正在读取");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "释放读锁");
            readLock.unlock();
        }
    }
    private static void write() {
        writeLock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "得到写锁，正在写入");
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "释放写锁");
            writeLock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        new Thread(() -> read()).start();
        new Thread(() -> read()).start();
        new Thread(() -> write()).start();
        new Thread(() -> write()).start();
    }
}

得到的运行结果

Thread-0得到读锁，正在读取
Thread-1得到读锁，正在读取
Thread-0释放读锁
Thread-1释放读锁
Thread-2得到写锁，正在写入
Thread-2释放写锁
Thread-3得到写锁，正在写入
Thread-3释放写锁

读写锁适用场合:适用于一般场合，ReadWriteLock 适用于 读多写少的情况，合理使用可以进一步提高并发效率。

源码解读

public interface ReadWriteLock {
/**
* Returns the lock used for reading.
*
* @return the lock used for reading.
*/
Lock readLock();
/**
* Returns the lock used for writing.
*
* @return the lock used for writing.
*/
Lock writeLock();
}

ReentrantReadWriteLock核心变量

  1. ReaderLock：读锁,实现了Lock接口
  2. WriterLock：写锁,也实现了Lock接口
  3. Sync：继承自AbstractQueuedSynchronize(AQS),可以为公平锁FairSync 或 非公平锁NonfairSync

ReentrantReadWriteLock相关属性和构造函数

/** 内部提供的读锁 */
private final ReentrantReadWriteLock.ReadLock readerLock;
/** 内部提供的写锁 */
private final ReentrantReadWriteLock.WriteLock writerLock;
/** AQS来实现的同步器 */
final Sync sync;
/**
* Creates a new {@code ReentrantReadWriteLock} with
* 默认创建非公平的读写锁
*/
public ReentrantReadWriteLock() {
    this(false);
}
/**
* Creates a new {@code ReentrantReadWriteLock} with
* the given fairness policy.
*
* @param fair {@code true} if this lock should use a fair ordering policy
*/
public ReentrantReadWriteLock(boolean fair) {
sync = fair ? new FairSync() : new NonfairSync();
readerLock = new ReadLock(this);
writerLock = new WriteLock(this);
}

Sync静态内部类的核心属性

abstract static class Sync extends AbstractQueuedSynchronizer {
// 版本序列号
private static final long serialVersionUID = 6317671515068378041L;
// 高16位为读锁，低16位为写锁
static final int SHARED_SHIFT = 16;
// 读锁单位
static final int SHARED_UNIT = (1 << SHARED_SHIFT);
// 读锁最大数量
static final int MAX_COUNT = (1 << SHARED_SHIFT) - 1;
// 写锁最大数量
static final int EXCLUSIVE_MASK = (1 << SHARED_SHIFT) - 1;
// 本地线程计数器
private transient ThreadLocalHoldCounter readHolds;
// 缓存的计数器
private transient HoldCounter cachedHoldCounter;
// 第一个读线程
private transient Thread firstReader = null;
// 第一个读线程的计数
private transient int firstReaderHoldCount;
}

tryAcquireShared方法

该方法其目的是尝试获取共享锁。

protected final int tryAcquireShared(int unused) {
    for (;;) {
        int c = getState();
        int nextc = c + (1 << 16);
        if (nextc < c) {
            throw new Error("Maximum lock count exceeded");
        }
        if (exclusiveCount(c) != 0 && owner != Thread.currentThread())
            return -1;
        if (compareAndSetState(c, nextc))
            return 1;
    }
}
  1. int c = getState();: 获取当前锁的状态值。在共享模式中，这个状态值通常表示持有锁的线程数量或其他相关信息。
  2. int nextc = c + (1 << 16);: 计算下一个状态值，这里是将当前状态值增加（左移）16位。在共享模式中，通常用高16位表示持有锁的线程数量。
  3. if (nextc < c) { throw new Error("Maximum lock count exceeded"); }: 检查是否超过了最大锁数量，如果超过了，抛出一个错误。这是一个防止溢出的保护措施。
  4. if (exclusiveCount(c) != 0 && owner != Thread.currentThread()) return -1;: 检查是否有线程持有独占锁（exclusiveCount© != 0），如果有且不是当前线程，则返回-1表示获取失败。这是因为共享锁和独占锁通常不能同时持有，这里保证了只有在没有独占锁被持有时，才能获取共享锁。
  5. if (compareAndSetState(c, nextc)) return 1;: 使用原子操作尝试将状态值更新为nextc。如果成功，表示获取锁成功，返回1。这里使用了 compareAndSetState 方法，该方法通常是一个原子的比较并设置操作，用于确保在并发情况下只有一个线程可以成功修改状态值。

tryAcquire方法

该方法尝试获取独占锁（写锁）

protected final boolean tryAcquire(int acquires) {
    /*
    * Walkthrough:
    * 1. If read count nonzero or write count nonzero
    * and owner is a different thread, fail.
    * 2. If count would saturate, fail. (This can only
    * happen if count is already nonzero.)
    * 3. Otherwise, this thread is eligible for lock if
    * it is either a reentrant acquire or
    * queue policy allows it. If so, update state
    * and set owner.
    */
    Thread current = Thread.currentThread();
    int c = getState(); // 获取当前同步状态

    // 获取独占锁(写锁)的被获取的数量
    int w = exclusiveCount(c);

    if (c != 0) {
        // (Note: if c != 0 and w == 0 then shared count != 0)
        // 1. 如果同步状态不为0，且写状态为0，则表示当前同步状态被读锁获取
        // 2. 或者当前拥有写锁的线程不是当前线程
        if (w == 0 || current != getExclusiveOwnerThread())
            return false;

        if (w + exclusiveCount(acquires) > MAX_COUNT)
            throw new Error("Maximum lock count exceeded");

        // Reentrant acquire
        setState(c + acquires); // 重入获取锁，更新同步状态
        return true;
    }

    // 如果没有读锁被持有，进入这个分支
    if (writerShouldBlock() || !compareAndSetState(c, c + acquires))
        return false;

    setExclusiveOwnerThread(current); // 设置当前线程为独占锁的拥有者
    return true;
}

解释：

  1. Thread current = Thread.currentThread();: 获取当前线程。
  2. int c = getState();: 获取当前同步状态。
  3. int w = exclusiveCount(c);: 获取独占锁（写锁）的被获取的数量。
  4. if (c != 0) { ... }: 如果当前同步状态不为0，表示有读锁或者写锁已经被持有。
  • 如果写锁数量为0或者当前拥有写锁的线程不是当前线程，则返回false表示获取锁失败。
  • 如果写锁数量不为0且当前拥有写锁的线程是当前线程，表示是重入获取锁。检查是否会超过最大锁数量，如果超过则抛出异常，否则更新同步状态并返回true。
  1. 如果当前同步状态为0，表示没有读锁被持有，进入这个分支。
  • writerShouldBlock(): 检查是否应该阻塞写锁，根据具体实现。
  • compareAndSetState(c, c + acquires): 使用CAS原子操作尝试获取锁。如果获取失败，表示有其他线程同时竞争锁，返回false。
  • 如果成功获取锁，设置当前线程为独占锁的拥有者，并返回true。

锁降级

意思就是持住写锁，再获取到读锁。
如下场景：

  1. 获取写锁： 线程首先获取了一个写锁，以保护一段临界区或共享资源。
  2. 完成写操作： 在写锁的保护下，线程执行了一些修改共享资源的操作。
  3. 获取读锁： 在完成写操作后，线程希望保持对共享资源的访问，但此时不再需要写锁的保护了。于是，线程降级锁，将写锁降级为读锁。
  4. 释放写锁： 最后，线程释放之前持有的写锁，只保持了读锁。

总结

此文章主要介绍了ReentrantReadWriteLock使用以及相关源码部分；更深刻的去理解读写锁的使用和使用场景。


http://lihuaxi.xjx100.cn/news/1890208.html

相关文章

postgreSql服务的window启动

postgreSql服务的window启动

CMD启动服务&#xff1a; D:\PostgreSQL\bin pg_ctl register -N PostgreSQL -D "D:\PostgreSQL\data # 登录 psql -U postgres # 验证输入 select 1; 拓展&#xff1a;删除服务 sc delete 服务名称 PostgreSQLUSER: postgresPWD: rootPORT: 5432动PostgreSQL服务器 3.1 打…
阅读更多...
关于“Python”的核心知识点整理大全18

关于“Python”的核心知识点整理大全18

目录 ​编辑 8.5 传递任意数量的实参 pizza.py 8.5.1 结合使用位置实参和任意数量实参 8.5.2 使用任意数量的关键字实参 user_profile.py 8.6 将函数存储在模块中 8.6.1 导入整个模块 pizza.py making_pizzas.py 8.6.2 导入特定的函数 8.6.3 使用 as 给函数指定别名…
阅读更多...
现代信号处理实验：MATLAB实现多分量信号的WV分布和模糊函数的绘制

现代信号处理实验：MATLAB实现多分量信号的WV分布和模糊函数的绘制

MATLAB实现多分量信号的WV分布和模糊函数的绘制 时域信号的傅氏谱&#xff08;傅里叶变换频谱&#xff09;、能量谱、功率谱都是信号变换到频域的一种表示&#xff0c;对于频谱不随时间变换的确定性信号和平稳随机信号而言&#xff0c;在频域分析中都可以很好的对信号进行分析…
阅读更多...
后台业务管理系统原型模板，Axure后台组件库（整套后台管理页面）

后台业务管理系统原型模板，Axure后台组件库（整套后台管理页面）

后台业务系统需要产品经理超强的逻辑思维能力和业务理解能力&#xff0c;整理了一批后台原型组件及完整的用 Axure 8 制作的后台系统页面&#xff0c;方便产品经理们快速上手制作后台原型。 包括交互元件、首页、商品、订单、库存、用户、促销、运营、内容、统计、财务、设置、…
阅读更多...
【PTA刷题】求链式线性表的倒数第K项（代码+详解）

【PTA刷题】求链式线性表的倒数第K项（代码+详解）

文章目录 题目代码详解 题目 给定一系列正整数&#xff0c;请设计一个尽可能高效的算法&#xff0c;查找倒数第K个位置上的数字。 输入格式: 输入首先给出一个正整数K&#xff0c;随后是若干非负整数&#xff0c;最后以一个负整数表示结尾&#xff08;该负数不算在序列内&#…
阅读更多...
软件设计不是CRUD（8）：低耦合模块设计实战——组织机构模块（下）

软件设计不是CRUD（8）：低耦合模块设计实战——组织机构模块（下）

接上文《软件设计不是CRUD&#xff08;7&#xff09;&#xff1a;低耦合模块设计实战——组织机构模块&#xff08;中&#xff09;》 5、某项目研发团队进行扩展 上文中我们介绍了如何研发一个具有较低耦合强度的组织机构模块&#xff08;包括模块的SDK和模块的默认本地数据库…
阅读更多...
机器学习笔记 什么是协方差矩阵？

机器学习笔记 什么是协方差矩阵？

一、协方差矩阵 协方差矩阵是一种矩阵，用于表示随机向量中给定的元素对之间的协方差值。协方差矩阵也可以称为色散矩阵或方差-协方差矩阵。这是因为每个元素的方差是沿着矩阵的主对角线表示的。 协方差矩阵始终是方阵。此外，它是半正定且对称的。该矩阵在随机建模和主成分分析…
阅读更多...
国产数据库适配-达梦（DM）

国产数据库适配-达梦（DM）

1、通用性 达梦数据库管理系统兼容多种硬件体系&#xff0c;可运行于X86、X64、SPARC、POWER等硬件体系之上。DM各种平台上的数据存储结构和消息通信结构完全一致&#xff0c;使得DM各种组件在不同的硬件平台上具有一致的使用特性。 达梦数据库管理系统产品实现了平台无关性&…
阅读更多...
最新文章

Copyright @ 2022~2023