22 多线程-读写锁分离

最新推荐文章于 2023-02-24 16:04:25 发布
最新推荐文章于 2023-02-24 16:04:25 发布
阅读量255 收藏
点赞数
分类专栏： 多线程 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyaoyao93/article/details/108521766
版权

文章目录

1 为什么读写分离

对于共享资源的读取是没有必要串行化，读取不会涉及对资源的修改，而写入操作是必须要保证线程安全的，
所以多线程下，如果读写分离，则可以提高效率，读数据是的是可以并行的，只有写的时候加锁串行

我们更多需求更多的时候就是读取的时候，允许多个线程去读取，但是在写如数据的时候，只能有一个线程去写入，其他线程不能进行读取和写入

2 实现

package study.wyy.concurrency.readWriteLock;

public class ReadWriteLock {
    /**
     * @Description: 当前正在读取数据线程数量
     */
    private int readingThreads = 0;

    /**
     * @Description: 等待去读取数据的线程的数量， 但是读取不了，放到了wait队列中
     */
    private int waitReadThreads = 0;

    /**
     * @Description: 正在写入数据的线程数量 只有一个
     */
    private int writingThreads = 0;

    /**
     * @Description: 记录当前有多少个线程想要写入，但是写入不了，放到了wait队列中，在等待其他释放锁
     */
    private int waitWriteThreads = 0;

    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 加读锁
     */
    public synchronized void readLock() throws InterruptedException {
        // 获取锁的时候，有可能获取不到锁，进入到等待队列（waitSet）中, 所以waitReadThreads可能需要加1的
        this.waitReadThreads++;
        try {
            while (writingThreads > 0) {
                // 当前有线程正在进行写入的时候，肯定是不能这个读取数据的线程肯定是不能进行读取数据的，进入等待
                // this.waitReadThreads++; 这个放在这里不合适，需要立马进入等待，就放到外面，但是可能会记录的数量不对
                this.wait();
            }
            // 此时没有线程进行写入数据，就可以读取数据了, 正在读取数据的线程数加1
            this.readingThreads++;
        } finally {
            // 最终释放锁的时候，要减减waitingReaders
            this.waitReadThreads--;
        }
    }

    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 释放读锁
     */
    public synchronized void readUnLock() throws InterruptedException {
        // 1 读取数据的线程的数量减1
        this.readingThreads--;
        // 2 释放
        this.notifyAll();
    }


    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 加写锁
     */
    public synchronized void writeLock() throws InterruptedException {
        // 获取锁的时候，有可能获取不到锁，进入到等待队列（waitSet）中, 所以waitWriteThreads可能需要加1的
        this.waitWriteThreads++;
        try {
            while (readingThreads > 0 || writingThreads > 0){
                // 当有其他线程在进行读取或者写入的时候，则当前线程不能进行写操作，只能等待
                this.wait();
            }
            // 没有其他线程在进行读取或者写入的时候，那就可以进行写入
            this.writingThreads++;
        } finally {
            // 最终释放锁的时候，要减减waitWriteThreads
            this.waitWriteThreads--;
        }
    }

    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 释放写锁
     */
    public synchronized void unWriteLock(){
        this.writingThreads--;
        this.notifyAll();
    }


}

3 测试

  • 定义数据
package study.wyy.concurrency.readWriteLock;

/**
 * @Description: 共享数据
 * @Author wyaoyao
 * @Date 2020/9/6 5:22 下午
 * @Param
 * @Return
 * @Exception
 */
public class ShareData {
    // 定义一个buffer，从里面读取数据和写入数据
    private final char[] buffer;

    // 定义一个锁
    private final ReadWriteLock lock = new ReadWriteLock();

    public ShareData(int size) {
        this.buffer = new char[size];
        // 初始化数据
        for (int i = 0; i < size; i++) {
            this.buffer[i] = '*';
        }
    }

    /**
     *  @author: wyaoyao
     *  @Date: 2020/9/6 5:27 下午
     *  @Description: 读取数据的方法
     */
    public  char[] read() throws InterruptedException {
        try {
            // 1 加读锁
            lock.readLock();
            // 2 读取数据
            return doRead();
        }finally {
            // 释放锁
            lock.readUnLock();
        }
    }

    private char[] doRead() {
        char[] temp = new char[buffer.length];
        for (int i =0; i<buffer.length;i++){
            temp[i] = buffer[i];
        }
        // 读取结束之后，休眠一会
        sleep(50);
        return temp;
    }

    private void sleep(int mills) {
        try {
            Thread.sleep(mills);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public void write(char c) throws InterruptedException {
        try {
            // 1 加写锁
            lock.writeLock();
            // 2 写数据
            doWrite(c);
        }finally {
            // 释放锁
            lock.unWriteLock();
        }
    }

    private void doWrite(char c) {
        for (int i =0; i<buffer.length;i++){
            buffer[i] = c;
            sleep(10);
        }
    }
}
  • 定义读取数据的线程
package study.wyy.concurrency.readWriteLock;

/**
 * @Description : 数据写入线程
 * @Author  wyaoyao
 * @Date   2020/9/6 6:05 下午
 * @Param
 * @Return
 * @Exception
 */
public class ReadThread extends Thread{

    private final ShareData shareData;

    public ReadThread(ShareData shareData) {
        this.shareData = shareData;
    }

    @Override
    public void run() {
        try{
            while (true){
                char[] data = shareData.read();
                System.out.println(Thread.currentThread().getName() + " read " + String.valueOf(data));
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }
}
  • 定义写入数据的线程
package study.wyy.concurrency.readWriteLock;


import java.util.Random;

/**
* @Description : 数据读取线程
* @Author  wyaoyao
* @Date   2020/9/6 6:05 下午
* @Param
* @Return
* @Exception
*/
public class WriterThread extends Thread{

    private static final Random random = new Random(System.currentTimeMillis());

    private final ShareData shareData;

    // 写入内容
    private final String content;

    private int index = 0;

    public WriterThread(ShareData shareData, String content) {
        this.shareData = shareData;
        this.content = content;
    }

    /**
     *  @author: wyaoyao
     *  @Date: 2020/9/6 6:45 下午
     *  @Description:
     *   这么写有问题
     */
//    @Override
//    public void run() {
//        while (true){
//            char c = nextChar();
//            try {
//                shareData.write(c);
//                // 如果在里中断，下次醒过来还可能从这里进行
//            } catch (InterruptedException e) {
//                e.printStackTrace();
//            }
//        }
//    }

    @Override
    public void run() {
        // 在这里，如果中断，就会进入到catch，不用自己break，
        // 因为run方法已经结束了
        try{
            while (true){
                char c = nextChar();
                shareData.write(c);
                Thread.sleep(random.nextInt(1000));
            }
        }catch (InterruptedException e){
            e.printStackTrace();
        }
    }

    /**
     *  @author: wyaoyao
     *  @Date: 2020/9/6 6:41 下午
     *  @Description: 获取content中的下一个字符
     */
    private char nextChar(){
        char c = content.charAt(index);
        index++;
        if(index>=content.length()){
            // 如果index大于content的长度，就重置一下
            index = 0;
        }
        return c;
    }
}
  • 测试类
package study.wyy.concurrency.readWriteLock;


/**
* @Description 测试
* @Author  wyaoyao
* @Date   2020/9/6 6:52 下午
* @Param
* @Return
* @Exception
*/
public class ReadWriteLockTest {

    public static void main(String[] args) {
        final ShareData shareData = new ShareData(10);
        new ReadThread(shareData).start();
        new ReadThread(shareData).start();
        new ReadThread(shareData).start();
        new ReadThread(shareData).start();
        new WriterThread(shareData,"qwertyuiop").start();
        new WriterThread(shareData,"QWERTYUIOP").start();
    }
}

运行结果发现，大部分是读取数据的线程抢到执行权，这也很正常，我们声明了4个读取数据的线程

4 改进

package study.wyy.concurrency.readWriteLock;

public class ReadWriteLock {
    /**
     * @Description: 当前正在读取数据线程数量
     */
    private int readingThreads = 0;

    /**
     * @Description: 等待去读取数据的线程的数量， 但是读取不了，放到了wait队列中
     */
    private int waitReadThreads = 0;

    /**
     * @Description: 正在写入数据的线程数量 只有一个
     */
    private int writingThreads = 0;

    /**
     * @Description: 记录当前有多少个线程想要写入，但是写入不了，放到了wait队列中，在等待其他释放锁
     */
    private int waitWriteThreads = 0;

    /**
     * @Description: 是否写入优先级更高
     */
    private boolean preferWrite;

    public ReadWriteLock(boolean preferWrite) {
        this.preferWrite = preferWrite;
    }

    public ReadWriteLock() {
        // 默认 true
        this(true);
    }

    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 加读锁
     */
    public synchronized void readLock() throws InterruptedException {
        // 获取锁的时候，有可能获取不到锁，进入到等待队列（waitSet）中, 所以waitReadThreads可能需要加1的
        this.waitReadThreads++;
        try {
            while (writingThreads > 0 || (preferWrite && this.waitWriteThreads>0))  {
                // 当前有线程正在进行写入的时候，肯定是不能这个读取数据的线程肯定是不能进行读取数据的，进入等待
                // 如果更偏爱写入，并且有写入的线程数量大于0，也让读取的线程进入等待
                // this.waitReadThreads++; 这个放在这里不合适，需要立马进入等待，就放到外面，但是可能会记录的数量不对
                this.wait();
            }
            // 此时没有线程进行写入数据，就可以读取数据了, 正在读取数据的线程数加1
            this.readingThreads++;
        } finally {
            // 最终释放锁的时候，要减减waitingReaders
            this.waitReadThreads--;
        }
    }

    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 释放读锁
     */
    public synchronized void readUnLock() throws InterruptedException {
        // 1 读取数据的线程的数量减1
        this.readingThreads--;
        // 2 释放
        this.notifyAll();
    }


    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 加写锁
     */
    public synchronized void writeLock() throws InterruptedException {
        // 获取锁的时候，有可能获取不到锁，进入到等待队列（waitSet）中, 所以waitWriteThreads可能需要加1的
        this.waitWriteThreads++;
        try {
            while (readingThreads > 0 || writingThreads > 0){
                // 当有其他线程在进行读取或者写入的时候，则当前线程不能进行写操作，只能等待
                this.wait();
            }
            // 没有其他线程在进行读取或者写入的时候，那就可以进行写入
            this.writingThreads++;
        } finally {
            // 最终释放锁的时候，要减减waitWriteThreads
            this.waitWriteThreads--;
        }
    }

    /**
     * @author: wyaoyao
     * @Date: 2020/9/6 6:10 下午
     * @Description: 释放写锁
     */
    public synchronized void unWriteLock(){
        this.writingThreads--;
        this.notifyAll();
    }


}
wyaoyao93
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java高并发编程详解系列-读写锁分离设计思想
初学者
07-20 2109
导语   在实际多线程情况下访问共享资源，需要对资源进行同步操作防止数据不一致的情况发生，通常使用的方法式是使用synchronized关键字或者是使用Lock显式锁的方式进行同步资源的锁定。   在对同步资源进行访问的时候不免有两种情况读操作和写操作，对于资源的增删改查不外乎就是这两种方式。当多个线程在对同一个资源进行访问的时候就会出现读写操作的竞争问题。也就是说在同一时刻多个线程同时读或者写...
多线程环境下的读写分离思考
qq_36683164的博客
05-16 491
文章目录场景一、synchronized 或者lock锁二、从kafka源码获取灵感 场景 当我们在多线程的环境下操作一个集合，比如 ArrayList或者Hashmap，这些集合默认情况下肯定是线程不安全的，如果说多个线程同时去读和写这些集合就会有线程安全问题。 好，问题来了，我们应该怎么让一个集合变成线程安全的呢？ 一、synchronized 或者lock锁 有一个非常简单的办法，对这些集合的访问都加上线程同步的控制，或者说是加锁。 最简单的做法就是加一个Synchronized或者Lock锁。 我
多线程设计模式： 读写锁分离设计模式
wyaoyao93的博客
04-05 384
文章目录1 场景引入2 读写分离模式设计 1 场景引入 在多线程的情况下访问共享资源，需要对资源进行同步操作以防止数据不一致的情况发生，通常我们可以使用synchronized关键字或者显式锁。 对资源的访问一般包括两种类型的动作——读和写（更新、删除、增加等资源会发生变化的动作），如果多个线程在某个时刻都在进行资源的读操作，虽然有资源的竞争，但是这种竞争不足以引起数据不一致的情况发生，那么这个时候直接采用排他的方式加锁，就显得有些简单粗暴了。 **其实多线程在同一时间都进行读操作时不会引起冲突之外，其余的
读写锁分离的循环队列
weixin_34380948的博客
03-10 128
在很多需要高性能的场合下，锁的设计一直是一个比较关键的问题。无锁队列、读写锁分离的队列在业界以及学术界都已经有很成熟的研究。在网上也有很多资料，但其实有很多实现都是错误的。最近在工作中帮忙追查一个线上问题时，就发现实现一个正确的版本是比较困难的事情。 背景：实现一个循环队列，队列长度已预先分配。支持不同线程的多写多读。 原本的实...
多线程环境下的读写分离思想
qq_36893229的博客
10-20 1170
一、场景 当我们在多线程的环境下操作一个集合，比如 ArrayList或者Hashmap，这些集合默认情况下肯定是线程不安全的，如果说多个线程同时去读和写这些集合就会有线程安全问题。 好，问题来了，我们应该怎么让一个集合变成线程安全的呢？ 二、synchronized 或者lock锁 有一个非常简单的办法，对这些集合的访问都加上线程同步的控制，或者说是加锁。 这里可以去另一篇文章看一下Synchronized和lock锁的原理简述synchronized和lock锁 最简单的做法就是加一个Synchroni
读写锁分离
ysmdelog的博客
04-17 132
package com.chaohu.cache; import java.util.HashMap; import java.util.Map; import java.util.concurrent.locks.ReentrantReadWriteLock; //缓存资源类 public class MyCache { public static void main(String[] args) { MyCache myCache = new MyCache();
多线程(22)读写锁分离模式1
08-04
总结来说，读写锁分离模式通过分离读锁和写锁，使得在多线程环境下，读操作可以并行执行，写操作保持互斥，从而优化了并发访问的效率。Java的`java.util.concurrent.locks.ReadWriteLock`接口提供了一种标准的实现...
Java多线程之readwritelock读写分离的实现代码
08-29
Java多线程之readwritelock读写分离的实现代码 Java多线程之readwritelock读写分离的实现代码主要介绍了Java多线程之readwritelock读写分离的相关内容，文中涉及具体实例代码，具有一定参考价值，需要的朋友可以...
行业分类-设备装置-读写锁控制方法及装置.zip
08-24
在IT行业中，读写锁（Read-Write Lock）是一种多线程编程中常见的同步机制，用于提高并发性能。它允许多个读者同时访问共享资源，但只允许一个写者独占资源，以避免数据的不一致性。这个压缩包“行业分类-设备装置-...
Java多线程编程之读写锁ReadWriteLock用法实例
09-03
Java的多线程编程中，读写锁（ReadWriteLock）是一种高效的并发控制机制，它将锁的权限进行了区分，允许多个线程同时读取资源，但仅允许一个线程进行写入操作。这种设计模式提高了数据共享的效率，因为读操作通常...
多线程——10读写分离锁
sui_feng_piao_guo的博客
02-22 2153
为什么需要读写分离锁 读 和 读的操作是不需要加锁的， 只有存在写操作才需要加锁 对共享变量的读 读操作不用锁 读和写不可同时发生 写和写也不可同时发生 实际上当读操作比较多时，此时的性能会更高 代码实现 public class ReadWriteLock { private int readingReaders; private int waitingReaders; ...
java多线程读写分离
最新发布
weixin_46607072的博客
02-24 133
java多线程读写分离
读写分离——读写锁ReadWriteLock
墨者的博客
07-12 1288
读写锁顾名思义分离读操作和写操作，可以有效的减少锁竞争以提高系统的性能。读写锁提升性能的地方主要在读读操作（读操作不会改变数据的一致性和完整性），而读写、写写、写读操作之间则会互斥造成阻塞。因此，读写锁应用场景适用于读操作次数大于写操作次数，读操作次数远大于写操作次数时，系统性能提升最明显。 ReadWriteLock接口定义了获取读锁和写锁两个方法，接下来对比串行的重入锁，来测试读写锁性能：
读写分离锁，读写锁设计模式
jue6628的博客
09-22 510
对于共享数据的操作无非读和写，多线程条件下，对于共享资源是否冲突，如下图： 如上可以看出对于写操作是不需要加锁的，这样可以很大提升性能；写操作都需要具有排他方式的加锁。 public class ReadWriteLock { //等待读操作线程数 private int watingReades; //正在读得线程数，这里支持多线程同时读取 private int readeingReades; //等待写的线程数 private int wateingW
JDK多线程基础(9)：读写分离锁 ReadWriteLock
Sam Blog
04-13 279
文章目录读写锁 ReadWriteLock简介简单实现参考 读写锁 ReadWriteLock 简介 读写分离锁是减少锁粒度的一种特殊情况，是对系统功能点的分割，其分割了读与写两种操作 适合场景：读多写少的场合。交互逻辑如下： 读锁之间是相容的，读锁在读读操作是不需要相互等待，提升多线程读数据的性能 写锁的占用是独占的 读锁 写锁 读锁 可访问 不可访问 写锁 不可访...
Java多线程之~~~ReadWriteLock 读写分离的多线程实现
iteye_2022的博客
09-19 191
在多线程开发中，经常会出现一种情况，我们希望读写分离。就是对于读取这个动作来说，可以同时有多个线程同 时去读取这个资源，但是对于写这个动作来说，只能同时有一个线程来操作，而且同时，当有一个写线程在操作这个资 源的时候，其他的读线程是不能来操作这个资源的，这样就极大的发挥了多线程的特点，能很好的将多线程的能力发挥 出来。 在Java中，ReadWriteLock这个接口就为我们实现了这个需求...
读写锁分离设计模式
雨天的麦子的博客
07-13 211
读写锁分离设计 为什么需要分离？ 在多线程下读取数据不能串行化，否则会导致效率下降。这里必须使用读写锁分离如下表所示 在读的情况时另外线程读操作，不需要同步 在读的情况，另外线程在写操作，必须同步加锁 一个线程在写入，另一个线程在读取需要同步加锁 一个线程在写入，另个线程在写需要同步加锁 public class ReadWriteDemo { private int readingReader = 0; private int waitingReader = 0; p
Java多线程锁机制深度解析
"这篇文章除了介绍ReentrantLock的使用外，还涉及多线程中的锁机制，可能包括其他类型的锁以及它们的应用场景。" 在多线程编程中，锁是确保线程安全和数据一致性的重要工具。这篇文章将探讨其中的一种——可重入锁...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值