二十六. 并发实战-读写锁的使用

已于 2023-01-28 20:46:38 修改
阅读量199 收藏
点赞数
分类专栏： JAVA并发编程 文章标签： Lock java 读写锁使用
于 2023-01-21 11:31:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sakura_Sacrifice/article/details/128745694
版权

前言

JUC并发包中提供了ReentrantReadWriteLock作为读写锁，本篇文章将对读写锁的如下四个场景进行演示。

  1. 当前线程获取读锁时，读锁是否被获取不会影响读锁的获取；
  2. 当前线程获取读锁时，若写锁未被获取或者写锁被当前线程获取，则允许获取读锁，否则进入等待状态；
  3. 当前线程获取写锁时，若读锁已经被获取，无论获取读锁的线程是否是当前线程，都进入等待状态；
  4. 当前线程获取写锁时，若写锁已经被其它线程获取，则进入等待状态。

正文

一. 场景一

本小节演示：当前线程获取读锁时，读锁是否被获取不会影响读锁的获取。示例如下。

public class ReentrantReadWriteLockTest {

    @Test
    public void 当前线程获取读锁_读锁是否被获取不会影响读锁的获取() throws Exception {
        // 创建读写锁
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        Lock readLock = reentrantReadWriteLock.readLock();

        // 创建CountDownLatch对象
        CountDownLatch countDownLatch = new CountDownLatch(2);

        // 创建任务
        Runnable readLockRunnable1 = new Runnable() {
            @Override
            public void run() {
                readLock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " 获取读锁");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // ignore
                } finally {
                    readLock.unlock();
                    countDownLatch.countDown();
                }
            }
        };
        Runnable readLockRunnable2 = new Runnable() {
            @Override
            public void run() {
                readLock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " 获取读锁");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // ignore
                } finally {
                    readLock.unlock();
                    countDownLatch.countDown();
                }
            }
        };

        // 线程1先获取读锁
        Thread thread1 = new Thread(readLockRunnable1, "线程1");
        thread1.start();

        // 线程2再获取读锁
        Thread thread2 = new Thread(readLockRunnable2, "线程2");
        thread2.start();

        // 阻塞主线程
        countDownLatch.await();
    }

}

上述示例中，演示了线程1和线程2先后获取读锁，如果获取到读锁，则打印一条日志。运行测试程序，结果如下。

在这里插入图片描述

运行结果表明，当前线程获取读锁时，读锁是否被获取不会影响读锁的获取。

二. 场景二

本小节演示：当前线程获取读锁时，若写锁未被获取或者写锁被当前线程获取，则允许获取读锁，否则进入等待状态。示例如下。

public class ReentrantReadWriteLockTest {

    @Test
    public void 当前线程获取读锁_若写锁已经被当前线程获取则当前线程能获取到读锁() throws Exception {
        // 创建读写锁
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        Lock readLock = reentrantReadWriteLock.readLock();
        Lock writeLock = reentrantReadWriteLock.writeLock();

        // 创建CountDownLatch对象
        CountDownLatch countDownLatch = new CountDownLatch(1);

        // 创建任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 先拿写锁
                writeLock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                    // 同一线程中再拿读锁
                    if (readLock.tryLock()) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " 获取到了读锁");
                        } finally {
                            readLock.unlock();
                        }
                    }
                } finally {
                    writeLock.unlock();
                    countDownLatch.countDown();
                }
            }
        };

        // 创建线程
        Thread thread = new Thread(runnable, "线程1");
        thread.start();

        // 阻塞主线程
        countDownLatch.await();
    }

}

上述示例中，演示了同一线程先后获取写锁和读锁，获取到对应锁后，打印日志。运行测试程序，结果如下所示。

在这里插入图片描述

运行结果表明，当前线程获取读锁时，若写锁被当前线程获取，则允许获取读锁。

再看如下示例。

public class ReentrantReadWriteLockTest {

    @Test
    public void 当前线程获取读锁_若写锁已经被其它线程获取则当前线程无法获取读锁() throws Exception {
        // 创建读写锁
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        Lock readLock = reentrantReadWriteLock.readLock();
        Lock writeLock = reentrantReadWriteLock.writeLock();

        // 创建CountDownLatch对象
        CountDownLatch countDownLatch = new CountDownLatch(2);

        // 创建拿写锁的任务
        Runnable writeLockRunnable = new Runnable() {
            @Override
            public void run() {
                writeLock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // ignore
                } finally {
                    writeLock.unlock();
                    countDownLatch.countDown();
                }
            }
        };
        // 创建拿读锁的任务
        Runnable readLockRunnable = new Runnable() {
            @Override
            public void run() {
                if (readLock.tryLock()) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " 获取到了读锁");
                    } finally {
                        readLock.unlock();
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + " 获取读锁失败");
                }
                countDownLatch.countDown();
            }
        };

        // 创建线程拿写锁
        Thread thread1 = new Thread(writeLockRunnable, "线程1");
        thread1.start();

        // 创建线程拿读锁
        Thread thread2 = new Thread(readLockRunnable, "线程2");
        thread2.start();

        countDownLatch.await();
    }

}

上述示例中，演示了线程1先获取写锁，线程2后获取读锁，并打印获取结果。运行测试程序，结果如下。

在这里插入图片描述
运行结果表明：当前线程获取读锁时，若写锁已被其它线程获取，则获取失败。

三. 场景三

本小节演示：当前线程获取写锁时，若读锁已经被获取，无论获取读锁的线程是否是当前线程，都进入等待状态。示例如下。

public class ReentrantReadWriteLockTest {

    @Test
    public void 当前线程获取写锁_若读锁已被当前线程获得则当前线程无法获取写锁() {
        // 创建读写锁
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        Lock readLock = reentrantReadWriteLock.readLock();
        Lock writeLock = reentrantReadWriteLock.writeLock();

        // 创建CountDownLatch对象
        CountDownLatch countDownLatch = new CountDownLatch(1);

        // 创建任务
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                // 先拿读锁
                readLock.lock();
                try {
                    System.out.println(Thread.currentThread().getName() + " 获取到了读锁");
                    // 同一线程中再拿写锁
                    if (writeLock.tryLock()) {
                        try {
                            System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                        } finally {
                            writeLock.unlock();
                        }
                    } else {
                        System.out.println(Thread.currentThread().getName() + " 获取写锁失败");
                    }
                } finally {
                    readLock.unlock();
                    countDownLatch.countDown();
                }
            }
        };

        // 创建线程并执行任务
        Thread thread = new Thread(runnable, "线程1");
        thread.start();

        // 阻塞主线程
        countDownLatch.countDown();
    }

}

上述示例中，演示了同一线程先获取读锁，再获取写锁，并打印获取结果。运行测试程序，结果如下。

在这里插入图片描述

运行结果表明：当前线程获取写锁时，若读锁已经被获取，无论获取读锁的线程是否是当前线程，都获取失败。

四. 场景四

本小节演示：当前线程获取写锁时，若写锁已经被其它线程获取，则进入等待状态。示例如下。

public class ReentrantReadWriteLockTest {

    @Test
    public void 当前线程获取写锁_若写锁已经被其它线程获取则获取失败() throws Exception {
        // 创建读写锁
        ReentrantReadWriteLock reentrantReadWriteLock = new ReentrantReadWriteLock();
        Lock writeLock = reentrantReadWriteLock.writeLock();

        // 创建CountDownLatch对象
        CountDownLatch countDownLatch = new CountDownLatch(2);

        // 创建拿写锁的任务
        Runnable writeLockRunnable = new Runnable() {
            @Override
            public void run() {
                if (writeLock.tryLock()) {
                    try {
                        System.out.println(Thread.currentThread().getName() + " 获取到了写锁");
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        // ignore
                    } finally {
                        writeLock.unlock();
                    }
                } else {
                    System.out.println(Thread.currentThread().getName() + " 获取写锁失败");
                }
                countDownLatch.countDown();
            }
        };

        // 创建线程1，拿写锁
        Thread thread1 = new Thread(writeLockRunnable, "线程1");
        thread1.start();

        // 创建线程2，拿写锁
        Thread thread2 = new Thread(writeLockRunnable, "线程2");
        thread2.start();

        // 阻塞主线程
        countDownLatch.await();
    }

}

上述示例中，演示了线程1先获取写锁，线程2后获取写锁，并打印获取结果。运行测试程序，结果如下。

在这里插入图片描述

上述结果表明：当前线程获取写锁时，若写锁已经被其它线程获取，则获取失败。

总结

读写锁ReentrantReadWriteLock的使用流程通常如下。

  1. 创建ReentrantReadWriteLock对象；
  2. 通过ReentrantReadWriteLock的readLock()方法创建读锁ReentrantReadWriteLock.WriteLock；
  3. 通过ReentrantReadWriteLock的writeLock()方法创建写锁ReentrantReadWriteLock.ReadLock；
  4. 后续加读锁通过ReentrantReadWriteLock.WriteLock，加写锁通过ReentrantReadWriteLock.ReadLock。

读写锁的使用规则总结如下。

  1. 当前线程获取读锁时，读锁是否被获取不会影响读锁的获取；
  2. 当前线程获取读锁时，若写锁未被获取或者写锁被当前线程获取，则允许获取读锁，否则进入等待状态；
  3. 当前线程获取写锁时，若读锁已经被获取，无论获取读锁的线程是否是当前线程，都进入等待状态；
  4. 当前线程获取写锁时，若写锁已经被其它线程获取，则进入等待状态。

读锁和写锁加锁时有两种方式。

  1. 通过lock()方法加锁，失败则进入同步队列等待；
  2. 通过tryLock()方法加锁，成功返回true，失败返回false。
樱花祭的约定
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
你知道什么是JAVA的读写锁，它的应用场景是什么？
weixin_39098944的博客
08-13 3145
什么是读写锁 百度百科的解析为： 读写锁实际是一种特殊的自旋锁，它把对共享资源的访问者划分成读者和写者，读者只对共享资源进行读访问，写者则需要对共享资源进行写操作 这种锁相对于自旋锁而言，能提高并发性，因为在多处理器系统中，它允许同时有多个读者来访问共享资源，最大可能的读者数为实际的逻辑CPU数。写者是排他性的，一个读写锁同时只能有一个写者或多个读者（与CPU数相关），但不能同时既有读者又有写者。在读写锁保持期间也是抢占失效的。 如果读写锁当前没有读者，也没有写者，那么写者可以立刻获得读写锁，否则它必须
netty、redis、zookeeper高并发实战-源代码
12-20
本项目源代码提供了基于Java实现的实战示例，帮助开发者深入理解并掌握这些技术在高并发环境下的应用。 **Netty** Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和...
读写锁：使用场景和实现方案（ZooKeeper 实现）
xmt1139057136的专栏
04-15 1611
你知道的越多，不知道的就越多，业余的像一棵小草！你来，我们一起精进！你不来，我和你的竞争对手一起精进！编辑：业余草http://rrd.me/g6P3V推荐：https://www.xtt...
读写锁 ReadWriteLock 适用场景
wujian_csdn_csdn的博客
03-05 3486
前言 在没有读写锁之前，ReentrantLock 虽然可以保证了线程安全，但是也浪费了一定的资源，因为如果多个读操作同时进行，其实并没有线程安全问题，我们可以允许让多个读操作并行，以便提高程序效率。 但是写操作不是线程安全的，如果多个线程同时写，或者在写的同时进行读操作，便会造成线程安全问题。 我们的读写锁就解决了这样的问题，它设定了一套规则，既可以保证多个线程同时读的效率，同时又可以保证有写入操作时的线程安全。 整体思路是它有两把锁，第 1 把锁是写锁，获得写锁之后，既可以读数据又可以修改数据，而第 2
读写锁可以用于什么应用场景？
学一次的博客
05-01 2215
读写锁可以用于 “多读少写” 的场景，读写锁支持多个读操作并发执行，写操作只能由一个线程来操作。
linux并发控制之读写自旋锁
williamwang2013的专栏
01-18 2500
读写自旋锁（rwlock）是一种比自旋锁粒度更小的自旋锁机制，它保留了“自旋”的概念。 但是在写操作方面，只能最多有一个写进程，在读方面，同时可拥有多个执行单元，当然读和写也不能同时进行。 一句话：防写不防读   理解推荐： http://blog.sina.com.cn/s/blog_6d7fa49b01014q86.html 操作： 定义于#include 或#include
netty-redis-zookeeper高并发实战学习-netty-redis-zookeeper.zip
11-06
在学习"Netty-Redis-Zookeeper高并发实战"的过程中，你可能会涉及到以下知识点： 1. Netty的基本概念和原理，包括其事件循环模型、ByteBuf的使用以及自定义编解码器的实现。 2. Redis的数据结构及其应用场景，如...
Java互联网架构多线程并发编程原理及实战 视频教程 下载.zip
最新发布
06-18
Java互联网架构多线程并发编程原理及实战 视频教程 下载 1-1 课程简介.mp4 1-2 什么是并发编程.mp4 1-3 并发编程的挑战之频繁的上下文切换.mp4 1-4 并发编程的挑战之死锁.mp4 1-5 并发编程的挑战之线程安全....
Node.js-node.jsexpressmongodb小电商项目实战
08-09
在本项目"Node.js-node.jsexpressmongodb小电商项目实战"中，我们将深入探讨如何使用Node.js、Express框架以及MongoDB数据库构建一个小型电子商务平台。这个实战教程将涵盖多个关键知识点，帮助开发者从零开始搭建...
java中Lock锁的应用简介
nhx900317的博客
04-20 1385
说到java，就不能不提多线程和锁，这篇文章简单介绍一下java中Lock的几种常用的应用方式。先简单介绍一下锁。锁，顾名思义，就是可以把东西锁住，在java里，可以理解为把一段代码锁住，只能让一个线程访问并执行，其他线程想再执行这段代码，就要等前面的线程结束才可以。
举例说明Java多线程编程中读写锁的使用
09-02
主要介绍了举例说明Java多线程编程中读写锁的使用,文中的例子很好地说明了Java的自带读写锁ReentrantReadWriteLock的使用,需要的朋友可以参考下
读写锁并发场景应用案例
qq_34893654的博客
02-25 380
连接池中的连接可以被多个并发请求共享，但是每个请求在使用连接时需要先获取一个可用的连接，然后在使用完成后释放连接。读写锁可以通过在获取连接时使用写锁，释放连接时使用写锁或读锁，以实现对连接池中的连接资源的安全访问。例如，在一个并发计算密集型的应用中，多个 goroutine 可以对一个共享的数组进行计算，使用读写锁可以允许多个 goroutine 同时进行读操作，在写操作时使用写锁进行互斥。需要注意的是，在使用读写锁时需要考虑到锁的粒度，不要让锁的粒度太大，否则会影响并发性能。结构体中包含一个连接池数组。
java读写锁使用场景_JUC并发系列(十)：超全透彻ReadWriteLock读写锁（应用场景+代码示例+关键代码剖析）...
weixin_39525313的博客
02-19 1241
跑起一个程序，并不难；难的是，能让程序跑多远！—— 一颗剽悍的种子JUC并发系列一、什么是 ReadWriteLock读写锁？准确来说 ReadWriteLock读写锁，应该是 读/写锁，正如ReadWriteLock 读/写锁也是分开来的，它管理着两个为一组的锁，一个是只读锁，一个是写锁。通过字面意思告诉你 ReadWriteLock读/写锁 其实你是很难理解的，因为只有通过案例，只有通过一行行...
Java并发（十一）：读写锁——写锁
GDUT_Trim的博客
10-16 1019
概述ReentrantReadWriteLock特性使用方法读写锁的实现分析如何使用位拆分去表示两种锁的重入状态呢？如何判断读锁和写锁获取写锁写锁的获取lock方法tryAcquiregetExclusiveOwnerThreadexclusivesetState写锁的释放tryRelease 概述 ReentrantLock和Mutex都是一个排他锁，也就是说，同一时刻只有一个线程可以去获取这把锁 但读写锁并不完全是排他锁，同一时刻是允许多个读线程来进行访问的，读写锁实际上指的是一对锁，读锁和写锁 读锁.
并发——读写锁
weixin_30916125的博客
05-18 103
1.并发控制 并发控制目的是当多个连接对数据库进行修改时保证数据的一致性。MySQL提供两个级别的并发控制：服务器级和存储引擎级。 1.1 读写锁 从功能上可以分为共享锁和排他锁，也就是我们常讲的读锁和写锁。简单描述就是：读锁是共享的，或者说是互相不阻塞的。多个用户在同一时刻可以同时读取统一资源，而互不干扰。写锁则是排他的， 也就是说一个写锁会阻塞其他的写锁和读锁。 ...
并发：读写锁（ReentrantReadWriteLock）。
孤芳不自赏
12-06 1095
ReentrantLock之类的基本都是排它锁，这些锁在同一时刻只允许一个线程进行访问，而读写锁在同一时刻可以允许多个读线程访问，但是在写线程访问时，所有的读线程和其他写线程均被阻塞。读写锁维护了一对锁，一个读锁和一个写锁，通过分离读锁和写锁，使得并发性相比一般的排它锁有了很大提升。 除了保证写操作对读操作的可见性以及并发行的提升之外，读写锁能够简化读写交互场景的编程方式。假设在程序中定义一个共...
POS线程同步互斥锁和读写锁的区别和各自适用场景
与狼共舞 的专栏
06-17 3354
读写锁特点：1）多个读者可以同时进行读2）写者必须互斥（只允许一个写者写，也不能读者写者同时进行）3）写者优先于读者（一旦有写者，则后续读者必须等待，唤醒时优先考虑写者） 互斥锁特点：  一次只能一个线程拥有互斥锁，其他线程只有等待 自旋锁：一次只能有一个进程进入临界区，读写锁是自旋锁的一个特例。 应用场景：以队列操作为例：线程A对队列负责将数据写入队列
各种锁以及使用场景
lyl194458的博客
05-28 3782
（1）互斥锁 一次只能一个线程拥有互斥锁，其他线程只有等待。互斥锁是在抢锁失败的情况下主动放弃CPU进入睡眠状态直到锁的状态改变时再唤醒，互斥锁在加锁操作时涉及上下文的切换。 （2）自旋锁 在任何时刻同样只能有一个线程访问对象。但是当获取锁操作失败时，不会进入睡眠，而是会在原地自旋，直到锁被释放。这样节省了线程从睡眠状态到被唤醒期间的消耗，在加锁时间短暂的环境下会极大的提高效率。但如果加锁时...
数据库的读锁和写锁在业务上的应用场景总结
weixin_30525825的博客
02-06 133
一、背景 熟悉MySQL数据库的朋友们都知道，查询数据常见模式有三种： 1. select ... ：快照读，不加锁 2. select ... in share mode：当前读，加读锁 3. select ... for update：当前读，加写锁 从技术层面理解三种方式的应用场景其实并不困难，下面我们先快速复习一下这三种读取模式的在技术层面上的区别。 注：为了简化问题的描述，下...
Node.js实战第二版 - Bradley Meck Alex Young
1. **Node.js基础**：介绍Node.js的基本架构，包括事件驱动模型、非阻塞I/O模型，以及如何利用这些特性来实现高并发、高性能的应用。 2. **V8引擎**：阐述V8引擎如何提供快速的JavaScript执行环境，以及它与Node.js...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

樱花祭的约定

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

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

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

打赏作者

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

抵扣说明：

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

余额充值