JUC高并发编程(13) -- 读写锁

最新推荐文章于 2024-02-27 22:18:12 发布
最新推荐文章于 2024-02-27 22:18:12 发布
阅读量174 收藏
点赞数
分类专栏： 高并发 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/jianghao233/article/details/124726943
版权
本文详细解析了Java并发包中的读写锁ReentrantReadWriteLock，包括读锁、写锁的工作原理、公平性、重入和降级特性，以及如何在实际场景中使用它优化对哈希映射的操作。通过实例演示了读写锁避免死锁和数据一致性问题。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

JUC高并发编程

九、读写锁

9.1）读写锁介绍

现实中有这样一种场景：对共享资源有读和写的操作，且写操作没有读操作那么频繁；在没有写操作的时候，多个线程同时读一个资源没有任何问题，所以应该允许多个线程同时读取共享资源；但是如果一个线程想去写这些共享资源， 就不应该允许其他线程对该资源进行读和写的操作了。 针对这种场景，JAVA的并发包提供了读写锁ReentrantReadWriteLock， 它表示两个锁，一个是读操作相关的锁，称为共享锁；一个是写相关的锁，称为排他锁。

9.1.1）读锁

读锁：是共享锁，会发生死锁的情况，如下图所示：

 上图中：二者互相等待产生死锁

  • 线程1修改数据的时候，需要等待线程2读取数据之后；

  • 线程2修改数据的时候，同样需要等待线程1读取数据之后；

线程进入读锁的前提条件：

  1. 没有其他线程的写锁

  2. 没有写请求, 或者有写请求，但调用线程和持有锁的线程是同一个(可重入锁)

9.1.2）写锁

写锁：是独占锁，会发生死锁的情况，如下图所示：

 上图中：二者互相等待产生死锁

  • 线程1对第一条数据进行写操作时候，同时对第二条数据进行修改操作【同一个线程中操作多条数据】需要等待线程2对第二条数据进行写操作之后才能够进行；

  • 线程2对第二条数据进行写操作时候，同时对第一条数据进行修改操作【同一个线程中操作多条数据】需要等待线程1对第一条数据进行写操作之后才能够进行；；

线程进入写锁的前提条件：

  1. 没有其他线程的读锁

  2. 没有其他线程的写锁

9.1.3）读写锁特性

读写锁有以下三个重要的特性：

（1）公平选择性：支持非公平（默认）和公平的锁获取方式，吞吐量还是非公平优于公平;

（2）重进入：读锁和写锁都支持线程重进入;

（3）锁降级：遵循获取写锁、获取读锁再释放写锁的次序，写锁能够降级成为读锁。

9.1.4）读写锁的演变

读写锁：一个资源可以被多个读线程访问，或者可以被一个写线程访问，但是不能同时存在读写线程，读写是互斥的，读读是共享的；

读写锁的演变过程如下图：

 9.2）ReentrantReadWriteLock

ReentrantReadWriteLock 类的整体结构如下：

public class ReentrantReadWriteLock implements ReadWriteLock, java.io.Serializable {
    private static final long serialVersionUID = -6992448646407690164L;
     /** 读锁 */ 
    private final ReentrantReadWriteLock.ReadLock readerLock;
     /** 写锁 */ 
    private final ReentrantReadWriteLock.WriteLock writerLock;
    /** Performs all synchronization mechanics */
    final Sync sync;
​
    /** 使用默认（非公平）的排序属性创建一个新的 ReentrantReadWriteLock */ 
    public ReentrantReadWriteLock() {
        this(false);
    }
​
    /** 使用给定的公平策略创建一个新的 ReentrantReadWriteLock */ 
    public ReentrantReadWriteLock(boolean fair) {
        sync = fair ? new FairSync() : new NonfairSync();
        readerLock = new ReadLock(this);
        writerLock = new WriteLock(this);
    }
     /** 返回用于写入操作的锁 */ 
    public ReentrantReadWriteLock.WriteLock writeLock() { return writerLock; }
     /** 返回用于读取操作的锁 */ 
    public ReentrantReadWriteLock.ReadLock  readLock()  { return readerLock; }
​
    ...

可以看到，ReentrantReadWriteLock实现了ReadWriteLock接口， ReadWriteLock接口定义了获取读锁和写锁的规范，具体需要实现类去实现； 同时其还实现了Serializable接口，表示可以进行序列化，在源代码中可以看到ReentrantReadWriteLock实现了自己的序列化逻辑。

9.3）读写锁案例

场景: 使用ReentrantReadWriteLock 对一个hashmap进行读和写操作

不添加读写锁ReentrantReadWriteLock ，代码如下：

//资源类
class MyCache {
    //创建map集合
    private volatile Map<String, Object> map = new HashMap<>();
​
    //放数据
    public void put(String key, Object value) {
        System.out.println(Thread.currentThread().getName() + " 正在写操作" + key);
        try {
            //暂停一会
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //放数据
        map.put(key, value);
        System.out.println(Thread.currentThread().getName() + " 写完了" + key);
    }
​
    //取数据
    public Object get(String key) {
        Object result = null;
        System.out.println(Thread.currentThread().getName() + " 正在读取操作" + key);
        //暂停一会
        try {
            TimeUnit.MICROSECONDS.sleep(300);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        result = map.get(key);
        System.out.println(Thread.currentThread().getName() + " 取完了" + key);
        return result;
    }
}
​
public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyCache myCache = new MyCache();
        //创建3个线程放数据
        for (int i = 1; i <= 3; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.put(num + "", num + "");
            }, String.valueOf(i)).start();
        }
        
        //创建3个线程取数据
        for (int i = 1; i <= 3; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.get(num + "");
            }, String.valueOf(i)).start();
        }
    }
}
输出：存在问题——写操作还未结束就进行了读操作

2 正在写操作2
3 正在写操作3
1 正在写操作1
1 正在读取操作1
2 正在读取操作2
3 正在读取操作3
3 取完了3
2 取完了2
2 写完了2
1 取完了1
3 写完了3
1 写完了1

添加读写锁ReentrantReadWriteLock ，代码如下：

//资源类
class MyCache {
    //创建map集合
    private volatile Map<String, Object> map = new HashMap<>();
​
    //创建读写锁对象
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();
​
    //放数据
    public void put(String key, Object value) {
        //添加写锁
        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + " 正在写操作" + key);
            //暂停一会
            TimeUnit.MICROSECONDS.sleep(300);
            //放数据
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + " 写完了" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放写锁
            rwLock.writeLock().unlock();
        }
    }
​
    //取数据
    public Object get(String key) {
        //添加读锁
        rwLock.readLock().lock();
        Object result = null;
        try {
            System.out.println(Thread.currentThread().getName() + " 正在读取操作" + key);
            //暂停一会
            TimeUnit.MICROSECONDS.sleep(300);
            result = map.get(key);
            System.out.println(Thread.currentThread().getName() + " 取完了" + key);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //释放读锁
            rwLock.readLock().unlock();
        }
        return result;
    }
}
​
public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyCache myCache = new MyCache();
        //创建3个线程放数据
        for (int i = 1; i <= 3; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.put(num + "", num + "");
            }, String.valueOf(i)).start();
        }
​
        TimeUnit.MICROSECONDS.sleep(300);
​
        //创建3个线程取数据
        for (int i = 1; i <= 3; i++) {
            final int num = i;
            new Thread(() -> {
                myCache.get(num + "");
            }, String.valueOf(i)).start();
        }
    }
}

输出：

2 正在写操作2
2 写完了2
1 正在写操作1
1 写完了1
3 正在写操作3
3 写完了3
1 正在读取操作1
2 正在读取操作2
3 正在读取操作3
2 取完了2
3 取完了3
1 取完了1

9.4）读写锁降级

读写锁降级：将写锁降级为读锁【读锁不能升级为写锁】

锁降级目的：为了提高数据的可见性，如果没有写操作就会读不到，读不到无法执行锁可重入的过程

jdk8中的锁降级流程如下图：

将写锁降级为读锁代码演示：

//演示读写锁降级【写锁降级为读锁】
public class ReadWriteLockDemo2 {
​
    public static void main(String[] args) {
        //可重入读写锁对象
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();//读锁
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();//写锁
​
        //锁降级
        //1 获取写锁
        writeLock.lock();
        System.out.println("---write");
​
        //2 获取读锁
        readLock.lock();
        System.out.println("---read");
​
        //3 释放写锁
        //writeLock.unlock();
​
        //4 释放读锁
        //readLock.unlock();
    }
}

输出：

---write

---read

读锁不能升级为写锁代码演示：

//演示读写锁降级【读锁不能升级为写锁】
public class ReadWriteLockDemo2 {
​
    public static void main(String[] args) {
        //可重入读写锁对象
        ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
        ReentrantReadWriteLock.ReadLock readLock = rwLock.readLock();//读锁
        ReentrantReadWriteLock.WriteLock writeLock = rwLock.writeLock();//写锁
​
        //锁降级
        //2 获取读锁
        readLock.lock();
        System.out.println("---read");
​
        //1 获取写锁
        writeLock.lock();
        System.out.println("---write");
​
        //3 释放写锁
        //writeLock.unlock();
​
        //4 释放读锁
        //readLock.unlock();
    }
}

输出：

---read

9.5）小结

  • 在线程持有读锁的情况下，该线程不能取得写锁(因为获取写锁的时候，如果发现当前的读锁被占用，就马上获取失败，不管读锁是不是被当前线程持有)；

  • 在线程持有写锁的情况下，该线程可以继续获取读锁（获取读锁时如果发现写 锁被占用，只有写锁没有被当前线程占用的情况才会获取失败）；

原因: 当线程获取读锁的时候，可能有其他线程同时也在持有读锁，因此不能把 获取读锁的线程“升级”为写锁；而对于获得写锁的线程，它一定独占了读写锁，因此可以继续让它获取读锁，当它同时获取了写锁和读锁后，还可以先释放写锁继续持有读锁，这样一个写锁就“降级”为了读锁。

JUC高并发编程从入门到精通（全）
码农研究僧的博客
08-06 1万+
目录前言 前言 在了解这部分内容的时候 先要了解java的一些基础内容 java零基础从入门到精通（全） javaSE从入门到精通（全） 所谓JUC是java.util .concurrent 工具包的简称这是一个处理线程的工具包可以实现多线程高并发的内容 了解该部分内容先了解线程与进程的相关概念 【操作系统】线程与进程的深入剖析（全） java之Thread类详细分析（全） 以及涉及到的lambda表达式函数的概念 java中lambda表达式 ......
JUC并发编程《Java-2021面试谈资系列》
zjdzka的博客
03-25 3289
JUC并发编程一、什么是JUC二、线程和进程三、Lock锁(重点)区别：四、生产者消费者五、8锁现象问题1，2问题3，4问题5，6问题7，8总结六、集合不安全CopyOnWriteArrayListCopyOnWriteSetConcurrentHashMap七、Callable八、常用辅助类CountDownLatchCyclicBarrierSemaphore九、读写锁十、阻塞队列方式一方式二方式三方式四同步队列十一、JMM十二、Volatile十三、单例模式十四、CAS十五、原子引用十六、各种锁的理解
聊聊高并发（十五）实现一个简单的读-写锁(共享-排他锁)
ITer_ZC的专栏
11-03 7833
读写锁是数据库中很常见的锁，又叫共享-排他锁，S锁和X锁。读写锁在大量读少量写的情况下有很高的效率优势。 读写锁是基于普通的互斥锁构建出来的更复杂的锁，它有两个基本特点： 1. 当任一线程持有读锁或写锁时，不允许其他线程再持有写锁 2. 当任一线程持有写锁时，不允许其他线程再持有读锁 也就是说，写锁是排他的，只要有一个线程持有写锁，就不允许其他线程再上锁。读锁是共享的，可以有多个线
高并发请求中的读写锁
weixin_34293059的博客
11-14 231
2019独角兽企业重金招聘Python工程师标准>>> ...
11 Redis之高并发问题(读+写) + 分布式锁 + Redisson的锁
m0_46671240的博客
02-27 3484
高并发问题 + 分布式锁+Redisson
JAVA高并发（JUC）之ReadWriteLock（读写锁）
Cocowwy的博客
05-20 763
这次讲解的数JUC的ReadWriteLock（读写锁）： 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。 但是，如果有一个线程想去共享资源类，就不应该再有其他线程可以对该资源进行读或写。 总结：读读共存 读写不共存 写写不共存 接下来先看个案例： 代码如下： public class ReadWriteLockDemo { public static void main(String[] args) { MyCache myCach
Java高级技术第五章——高并发之读写锁(ReadWriteLock)
技术笔记
04-23 870
前言 前言点击此处查看: http://blog.youkuaiyun.com/wang7807564/article/details/79113195 ReadWriteLock ReadWriteLock也是一个接口，在它里面只定义了两个方法： public interface ReadWriteLock { /** * Returns the lock used fo...
Java 多线程与并发(10-26)-JUC锁- 锁核心类AQS详解.pdf
07-23
Java并发包（java.util.concurrent，简称JUC）提供了一系列工具和类库来帮助开发者简化并发编程的工作。其中，AbstractQueuedSynchronizer（简称AQS）是构建各种同步器的核心组件。 AQS是一个抽象的队列同步器，它...
java并发编程-AQS和JUC实战
最新发布
04-29
### Java并发编程-AQS和JUC实战 #### 一、ReentrantLock 重入锁 **1.1 概述** - **基本介绍**: `ReentrantLock` 是一个实现了 `Lock` 接口的可重入互斥锁，提供比 `synchronized` 更丰富的功能。与 `synchronized...
Java 多线程与并发(12-26)-JUC锁- ReentrantReadWriteLock详解.pdf
07-26
在Java多线程并发编程中，ReentrantReadWriteLock（可重入读写锁）是一个重要的同步工具，它属于Java并发包（java.util.concurrent.locks）中的一个类。这个锁提供了比标准的synchronized关键字更细粒度的控制，允许...
高并发--卷4--读写锁
qq_25956141的博客
07-22 200
ReentrantLock锁的互斥性决定了同一时间内lock()下只能有一个线程在执行。 但是对于读和读的情况，却没必要让两个线程互斥，对于读写，写读，写写需要进行互斥，所以，JDK中提出了一种读写锁的机制，ReentrantReadWriteLock() 读读 读读不会互斥。 import java.util.concurrent.locks.ReentrantRea...
Java——多线程高并发系列之ReadWriteLock读写锁
贝尔摩德苦艾酒
06-11 7125
Java——多线程高并发系列之ReadWriteLock读写锁
【高并发系列】12、读写锁 ReadWriteLock
hellboy0621的博客
02-13 257
java.util.concurrent.locks.ReadWriteLock是JDK5提供的读写分离锁； 读-读不互斥：读读之间不阻塞； 读-写互斥：读阻塞写，写阻塞读； 写-写互斥：写写阻塞； 在系统中，如果读操作次数远远大于写操作次数，则读写锁可以发挥最大的功效，提升系统的性能； public class ReadWriteLockDemo { private static L...
Java多线程高并发（读写锁ReentrantReadWriteLock）
weixin_30690833的博客
08-17 152
package com.thread.dome; 2 3 import java.util.Map; 4 import java.util.concurrent.ConcurrentHashMap; 5 import java.util.concurrent.ExecutorService; 6 import java.util.concurrent.Exec...
JUC高并发编程(六)——读写锁的使用和锁降级
weixin_45726752的博客
08-17 197
读写锁的使用和锁降级
高并发服务优化篇：详解一次由读写锁引起的内存泄漏
m0_71777195的博客
06-23 262
JVM相关的异常，一直是一线研发比较头疼的问题。因为对于业务代码，JVM的运行基本算是黑盒，当异常发生时，较难直观地看到和找到问题所在，这也是我们一直要研究其内部逻辑的原因。本篇就有一个近期线上JVM内存泄漏的例子，带大家强行分析一波~某天，同事来找我帮忙，原来是某系统毫无征兆地来了一连串报警，一波机器的老年代内存占用率超过阈值~老年代内存占用可以看到，在7月中旬之前，内存占用还是比较正常的，每次GC都可以回收掉很大一部分的老年代对象。而中旬之后，老年代内存一直缓慢增长而无法释放。很明显，应该是对象没法被正
Java高并发编程---读写锁
喜三仔的世界
09-24 356
 前面提到的锁基本都是排他锁，就是在同一时刻只允许一个线程访问的锁。现在有一个新的概念：读写锁。这种锁分离了读和写操作，因而允许在同一时刻多个读线程访问，而只能有一个写线程访问，这一模式使得并发性相比一般的排他锁有了很大的提升。  除了保证写操作对读操作的可见性以及并发性的提升之外，读写锁能够简化读写交互场景的编程方式。  一般情况下，读写锁的性能都会比排它锁好，因为大多数场景读是多于写的。在读多...
go语言中高并发读写锁详解
qq_30505673的博客
08-11 5668
package main import ( &amp;amp;quot;sync&amp;amp;quot; &amp;amp;quot;time&amp;amp;quot; ) var m *sync.RWMutex func main() { m = new(sync.RWMutex) //写的时候啥都不能干 go write(1) go read(2) go write(3) time.Sleep(4 * time.Second)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值