狂神说JAVA-JUC并发编程（三）ReadWriteLock

最新推荐文章于 2021-12-06 10:31:09 发布
最新推荐文章于 2021-12-06 10:31:09 发布
阅读量136 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ningmengshuxiawo/article/details/118244805
版权

A ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的。
所有ReadWriteLock实现必须保证的存储器同步效应writeLock操作（如在指定Lock接口）也保持相对于所述相关联的readLock 。 也就是说，一个线程成功获取读锁定将会看到在之前发布的写锁定所做的所有更新。

读写锁允许访问共享数据时的并发性高于互斥锁所允许的并发性。 它利用了这样一个事实：一次只有一个线程（ 写入线程）可以修改共享数据，在许多情况下，任何数量的线程都可以同时读取数据（因此读取器线程）。从理论上讲，通过使用读写锁允许的并发性增加将导致性能改进超过使用互斥锁。 实际上，并发性的增加只能在多处理器上完全实现，然后只有在共享数据的访问模式是合适的时才可以。

读写锁是否会提高使用互斥锁的性能取决于数据被读取的频率与被修改的频率相比，读取和写入操作的持续时间以及数据的争用 - 即是，将尝试同时读取或写入数据的线程数。 例如，最初填充数据的集合，然后经常被修改的频繁搜索（例如某种目录）是使用读写锁的理想候选。 然而，如果更新变得频繁，那么数据的大部分时间将被专门锁定，并且并发性增加很少。 此外，如果读取操作太短，则读写锁定实现（其本身比互斥锁更复杂）的开销可以支配执行成本，特别是因为许多读写锁定实现仍将序列化所有线程通过小部分代码。 最终，只有剖析和测量将确定使用读写锁是否适合您的应用程序。

虽然读写锁的基本操作是直接的，但是执行必须做出许多策略决策，这可能会影响给定应用程序中读写锁定的有效性。 这些政策的例子包括：

在写入器释放写入锁定时，确定在读取器和写入器都在等待时是否授予读取锁定或写入锁定。 作家偏好是常见的，因为写作预计会很短，很少见。 读者喜好不常见，因为如果读者经常和长期的预期，写作可能导致漫长的延迟。 公平的或“按顺序”的实现也是可能的。
确定在读卡器处于活动状态并且写入器正在等待时请求读取锁定的读取器是否被授予读取锁定。 读者的偏好可以无限期地拖延作者，而对作者的偏好可以减少并发的潜力。
确定锁是否可重入：一个具有写锁的线程是否可以重新获取？ 持有写锁可以获取读锁吗？ 读锁本身是否可重入？
写入锁可以降级到读锁，而不允许插入写者？ 读锁可以升级到写锁，优先于其他等待读者或作者吗？
在评估应用程序的给定实现的适用性时，应考虑所有这些问题。

拉姆达表达式无法访问外部变量，只能访问final的变量，下面的temp定义的时候就默认是final了
在这里插入图片描述

不加锁

我们看看不加锁的情况

package juc;

import java.util.HashMap;
import java.util.Map;

/**
 * Created by 此生辽阔 on 2021/6/26 11:08
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache=new MyCache();
        for(int i=0;i<5;i++)
        {
           int temp=i;
            new Thread(()->{
                myCache.write(temp+"",temp+"");
                myCache.read(temp+"");
              //  temp=4;//temp由于在拉姆达表达式中使用了，被默认是final，不能修改
            },"线程"+i).start();
        }
        }
    }
    
class MyCache{
    private Map<String ,Object> map=new HashMap<>();
    public void read(String key)
    {
        System.out.println(Thread.currentThread().getName() + "开始读取");
        map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取完成");
    }
    public void write(String key,Object value)
    {
        System.out.println(Thread.currentThread().getName() + "开始写入");
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "写入完成");
    }
}

在这里插入图片描述

Lock

我们希望写入的时候能够互斥的，就是对于同一个myCache,一个线程写完了，才允许另一个线程接着写

 Lock lock=new ReentrantLock();

   public void write(String key,Object value)
    {
        lock.lock();
        System.out.println(Thread.currentThread().getName() + "开始写入");
        map.put(key,value);
        System.out.println(Thread.currentThread().getName() + "写入完成");
        lock.unlock();
    }

在这里插入图片描述

但是代码是不规范的，我们应该把 lock.unlock();放在finally语句，保证一定被执行
在这里插入图片描述

   public void write(String key, Object value) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入完成");
        } finally {
            lock.unlock();
        }
    }

ReadWriteLock

在读的时候，我们希望多个线程可以一起读的，而且要求写的时候也是可以读的，那么我们需要使用到粒度更细的ReadWriteLock。

  ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始读取");
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

我的代码

package juc;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * Created by 此生辽阔 on 2021/6/26 11:08
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
       // MyCache myCache = new MyCache();
        MyCacheLock myCache=new MyCacheLock();
        for (int i = 0; i < 5; i++) {
            int temp = i;
            new Thread(() -> {
                myCache.write(temp + "", temp + "");
                myCache.read(temp+"");
                //  temp=4;//temp由于在拉姆达表达式中使用了，被默认是final，不能修改
            }, "线程" + i).start();
        }
    }
}

class MyCache {
    private Map<String, Object> map = new HashMap<>();
    Lock lock = new ReentrantLock();

    public void read(String key) {
        System.out.println(Thread.currentThread().getName() + "开始读取");
        map.get(key);
        System.out.println(Thread.currentThread().getName() + "读取完成");
    }

    public void write(String key, Object value) {
        lock.lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入完成");
        } finally {
            lock.unlock();
        }
    }
}
class MyCacheLock {
    private Map<String, Object> map = new HashMap<>();
    ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void read(String key) {
        lock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始读取");
            map.get(key);
            System.out.println(Thread.currentThread().getName() + "读取完成");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }
    }

    public void write(String key, Object value) {
        lock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName() + "开始写入");
            map.put(key, value);
            System.out.println(Thread.currentThread().getName() + "写入完成");
        } finally {
            lock.writeLock().unlock();
        }
    }
}

狂神的代码

package com.kuang.rw;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 独占锁（写锁） 一次只能被一个线程占有
 * 共享锁（读锁） 多个线程可以同时占有
 * ReadWriteLock
 * 读-读  可以共存！
 * 读-写  不能共存！
 * 写-写  不能共存！
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCache myCache = new MyCache();

        // 写入
        for (int i = 1; i <= 5 ; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        // 读取
        for (int i = 1; i <= 5 ; i++) {
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }

    }
}

// 加锁的
class MyCacheLock{

    private volatile Map<String,Object> map = new HashMap<>();
    // 读写锁： 更加细粒度的控制
    private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock lock = new ReentrantLock();

    // 存，写入的时候，只希望同时只有一个线程写
    public void put(String key,Object value){
        readWriteLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.writeLock().unlock();
        }
    }

    // 取，读，所有人都可以读！
    public void get(String key){
        readWriteLock.readLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取OK");
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            readWriteLock.readLock().unlock();
        }
    }
}

/**
 * 自定义缓存
 */
class MyCache{

    private volatile Map<String,Object> map = new HashMap<>();

    // 存，写
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入OK");
    }

    // 取，读
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取OK");
    }
}
此生辽阔
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JUC并发编程（九）- 读写锁ReadWriteLock详解
二总的猫
02-26 232
9、读写锁：ReadWriteLock 读写分离：读写分离是一种思想。 ​ 之前讲的Lock是一个同步锁，它对资源的读和写，要么都锁住，要么都不锁，有的时候我们的资源，希望读的时候不锁，写的时候锁住，这样在安全的基础上能提高很大的效率。 ​ 我们希望锁只添加在需要的地方，如在写的时候，加锁，只允许一个线程去操作，读的时候不加锁，所有的线程都可以去读。 这样ReadWrite...
基于《狂神说Java》JUC并发编程--学习笔记
wudidahuanggua的博客
06-15 831
本笔记仅做学习与复习使用，不存在刻意抄袭。给各位学友强烈推荐《遇见狂神说》他的整套Java学习路线使我获益匪浅！！!点击跳转至遇见狂神说哔哩哔哩首页如果你也是狂神的小迷弟，可以加我好友一起探讨学习。 ...
JUC并发编程狂神说笔记（超详细）
weixin_48412846的博客
06-27 6603
List item List item List item List item
【狂神说Java】JUC并发编程
ZJC'博客
12-06 721
【狂神说Java】JUC并发编程 准备工作 新建一个Maven项目，引入一个lombok依赖. <dependencies> <dependency> <groupId>org.projectlombok</groupId> <artifactId>lombok</artifactId> <version>1.18.8</vers
狂神说JAVA-JUC并发编程（一）线程、生产者消费者、锁、synchronized、Lock
想握住此生辽阔
01-28 697
1
狂神说Java-SpringMVC学习笔记
05-17
狂神说Java——SpringMVC学习笔记 内容概要： 1、了解什么是SpringMVC 2、RestFul和控制器 3、转发和重定向 4、数据处理 5、JSON 6、SSM项目整合 7、Ajax 8、拦截器+文件上传下载 能学到什么：详细了解SpringMVC基础...
狂神说Java-Spring学习笔记
最新发布
05-17
### 知识点详解 #### 1. 什么是Spring？ Spring是一个开源的Java平台框架，由Rod Johnson在2002年创立，并于2004年发布首个...此外，对于初学者来说，结合相关的教学视频进行学习，会更容易理解和掌握这些知识点。
狂神说Java-Mybatis学习笔记
05-17
### 狂神说Java-Mybatis学习笔记 #### 一、MyBatis概述与环境搭建 ##### 1.1 什么是MyBatis MyBatis是一款优秀的持久层框架，其核心设计理念在于避免几乎所有的JDBC代码和手动设置参数以及获取结果集的过程。通过...
JUC并发编程，狂神说-详细笔记，含md文件
04-07
主要记录了狂神说Java里JUC那一门课的笔记，主要针对学了狂神的JUC课程的人用来复习的，我记录得还是比较详细，也自己画了不少的图，还根据弹幕大神做了一些修改，对于复习来说应该不成问题，总共有一万多字。
狂神说Java-多线程课程全部代码.rar
11-26
《狂神说Java-多线程课程全部代码》是一个涵盖了Java多线程和并发编程的实战教程资源。这个压缩包包含了一系列的示例代码（如demo01），旨在帮助开发者深入理解和掌握Java中的多线程技术及其在并发环境中的应用。 ...
牛客刷题笔记--并发
想握住此生辽阔
07-06 3709
1 下面关于并行和并发的区别，说法错误的是？（C） 并发计算是一种程序计算的形式，在系统中，至少有两个以上的计算在同时运作，计算结果可能同时发生 并行计算指许多指令得以同时进行的计算模式。在同时进行的前提下，可以将计算的过程分解成小部份，之后以并发方式来加以解决 并行是同时发生的多个并发事件，并发事件之间一定要同一时刻发生 并发是逻辑上的同时发生（simultaneous），而并行是物理上的同时发生 答： 并发和并行的区别就是一个处理器同时处理多个任务和多个处理器或者是多核的处理器同时处理多个不同的任务。
狂神说Java-多线程学习笔记
想握住此生辽阔
01-24 2253
线程简介 多任务：边吃饭边玩手机，同时做多件事（但是实际上是分时进行的，大脑分时处理，时间交替很快） 多线程：多车道，多条线路同时执行任务 普通方法调用和多线程 直接调用run和调用start函数的不同，直接调用run函数无法实现多线程 在操作系统中运行的程序就是进程（qq,播放器，游戏，IDE），播放视频时有声音，图像，字幕，这些就是由不同的线程控制 进程与线程 说起进程，就不得不说下程序，程序是数据和指令的有序集合，其本身没有任何运行的含义，是一个静态的概念 而进程是执行程序的一次执行过程，它是一个动
力扣-多线程专项（一）（按序打印、交替打印、打印零与奇偶数）
想握住此生辽阔
01-25 608
1114. 按序打印 我们提供了一个类： public class Foo { public void first() { print("first"); } public void second() { print("second"); } public void third() { print("third"); } } 三个不同的线程将会共用一个 Foo 实例。 线程 A 将会调用 first() 方法 线程 B 将会调用 second() 方法 线程 C 将会调用 third() 方法
java多线程专项（进程和线程的区别）
想握住此生辽阔
03-07 577
实现多线程的方法： 1.继承Thread类 2.实现Runnable接口 3.实现Callable接口 实现多线程的方法： 1.继承Thread类 2.实现Runnable接口 3.实现Callable接口,然后使用 FutureTask包装，因为Callable接口没有实现Runnable接口不能做为Thread的target，而FutureTask是在Java程序中可以取消的异步运算，有可以开始，取消运算，查询运算是否结束，获得查询结果的功能，特别注意的是，如果查询结果时，运算还没完成则会阻塞线程。 4
狂神说JAVA-JUC并发编程（二）线程不安全的集合、JUC常用的辅助类
想握住此生辽阔
02-12 454
总结知识点 小狂神的学习方法推荐：1、先会用、2、货比3家，寻找其他解决方案，3、分析源码！ Arraylist的foreach遍历方法 生成随机字符串的方法：UUID（Universally Unique Identifier）：通用唯一识别码 并发下 ArrayList 不安全的解决方案；Collections工具类下有同步的集合，比如SynchronizedList 线程不安全的集合 CopyOnWriteArrayList Arrarlist测试（单线程） public class ListTest
狂神说JAVA-JUC并发编程（五）线程池
想握住此生辽阔
06-27 345
程序运行的本质是占用系统资源，为了优化资源的使用，引入了池化技术 比如线程池、连接池。内存池、对象池 jdbc连接池会有一个最小的池（就是默认有几个连接的），有一个最大的池 因为连接跟关闭的时候是非常消耗资源的 池化技术：事先准备好一些资源，有人要用，就来拿，用完就归还 线程池的好处：降低资源消耗，提高响应速度,方便管理线程，线程可以复用，可以控制最大并发数 三大方法 7大参数 4种拒绝策略 三大方法 Executors.newSingleThreadExecutor() package juc;
并发面试题1：synchronized和lock的区别
想握住此生辽阔
04-12 342
保证线程安全 用synchronized修饰方法或者代码块 lock给代码块加锁 synchronized和lock的区别 synchronized属于jvm层面，是java的关键字，lock是API层面，是java5以后的一个类 synchronized底层主要是monitorenter和monitorexit monitorenter(底层是通过monitor对象来完成，其实wait /notify等方法也依赖于monitor对象,所以只有在同步块或方法中才能调wait/notify等方法 syn
狂神说JAVA-JUC并发编程（七）JMM Volatile 单例 CAS 原子引用 各种锁的理解
想握住此生辽阔
07-01 238
Volatile是Java虚拟机提供的轻量级同步机制 1 保证可见性 2 不保证原子性 3 禁止指令重排 JMM JAVA内存模型，是一个概念，是不存在的东西，是一种约定 关于JMM的同步的约定： 1线程解锁的时候必须把共享变量立刻刷新回主内存（因为线程会把主存中的变量拷贝一份，线程操作的都是主存变量的拷贝，所以需要把做的更改刷新回主存） 2 线程加锁前，必须读取主存中变量的最新值到线程的工作内存中 3加锁和解锁是同一把锁 线程 工作内存 主内存 （弹幕：工作内存想到那个鱼虚拟机栈帧中的局部变量表 主存
一些多线程技术文
想握住此生辽阔
07-29 162
进程间通信
狂神说java-juc并发编程
09-23
狂神说java-juc并发编程是指狂神在讲解Java并发编程时提到了Java Util Concurrent（简称JUC）这个包。JUC是Java中用于处理并发编程的三个包之一，它包含了一系列的并发工具类和线程安全的集合类。其中，java.util....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值