Java读写锁分离设计模式

prtyaa
prtyaa 2023-12-30 21:26:59 51108 赞同 0 反对 0
分类： 资源
在多线程的环境下，对于共享资源的访问，为了防止资源出现不同步的情况出现，可以使用synchronized关键字对资源进行同步，使得同一时间只有一个线程能够访问共享资源。但synchronized是具有排他性质的锁，使用它会降低系统性能，而我们知道对于共享资源的操作，可以归为两类：读和写。而读操作并不会影响共享资源，而写操作才需要进行同步，对此可以设计出一种读写分离模式的锁，在同一时间可以要么只能读，要么只能写，而读线程可以有多个，写线程只能有一个。

定义锁的接口，解锁和加锁方法

public interface Lock {
    void lock() throws InterruptedException;
    void unlock();
}

定义读写锁的接口

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
    int getWritingWriters();
    int getWaitingWriters();
    int getReadingReaders();

    //工厂方法，创建ReadWriteLock，下面是带构造参数传
    static ReadWriteLock readWriterLock(){
        return new ReadWriteLockImp();
    }
    static ReadWriteLock readWriterLock(boolean preferWriter){
        return new ReadWriteLockImp(preferWriter);
    }
}

3个get方法分别是：

  1. 获取正在写入中的线程数（只能为0和1）
  2. 获取等待写入的线程数
  3. 获取正在读取的线程数

读写锁实现:

public class ReadWriteLockImp implements ReadWriteLock {
    //定义对象锁
    private final Object MUTEX = new Object();
    //当前有多少个线程写入
    private int writingWriters = 0;
    //当前多少个线程正在等待写入
    private int waitingWriters = 0;
    //当前多少个线程正在读
    private int readingReaders = 0;
    //是否偏好于写
    private boolean preferWriter;

    //不填默认为true
    public ReadWriteLockImp() {
        this(true);
    }

    public ReadWriteLockImp(boolean preferWriter) {
        this.preferWriter = preferWriter;
    }

    @Override
    public Lock readLock() {
        return new ReadLock(this);
    }

    @Override
    public Lock writeLock() {
        return new WriteLock(this);
    }

    //正在写的线程增加1
    public void incrementWritingWriters() {
        this.writingWriters++;
    }

    //等待写的线程增加1
    public void incrementWaitingWriters() {
        this.waitingWriters++;
    }

    //正在读的线程增加1
    public void incrementReadingReaders() {
        this.readingReaders++;
    }

    //反之
    public void decrementWritingWriters() {
        this.writingWriters--;
    }

    public void decrementWaitingWriters() {
        this.waitingWriters--;
    }

    public void decrementReadingReaders() {
        this.readingReaders--;
    }

    @Override
    public int getWritingWriters() {
        return this.writingWriters;
    }

    @Override
    public int getWaitingWriters() {
        return this.waitingWriters;
    }

    @Override
    public int getReadingReaders() {
        return this.readingReaders;
    }

    //获取对象锁
    public Object getMUTEX() {
        return MUTEX;
    }

    //获取是否偏向写锁
    public boolean getPreferWriter() {
        return preferWriter;
    }

    //设置偏好锁
    public void setPreferWriter(boolean preferWriter) {
        this.preferWriter = preferWriter;
    }
}

读锁的实现：

public class ReadLock implements Lock {
    private final ReadWriteLockImp readWriteLockImp;

    public ReadLock(ReadWriteLockImp readWriteLockImp) {
        this.readWriteLockImp = readWriteLockImp;
    }

    @Override
    public void lock() throws InterruptedException {
        //使用对象锁
        synchronized (readWriteLockImp.getMUTEX()) {
            //如果现在有写操作，或者有写操作正在等待写入且偏好写，则只能挂起等待
            while (readWriteLockImp.getWritingWriters() > 0 ||
                    (readWriteLockImp.getPreferWriter()
                            && readWriteLockImp.getWaitingWriters() > 0)) {
                readWriteLockImp.getMUTEX().wait();
            }
            //获取锁成功
            readWriteLockImp.incrementReadingReaders();
        }
    }

    @Override
    public void unlock() {
        synchronized (readWriteLockImp.getMUTEX()) {
            //读线程数量减一
            readWriteLockImp.decrementReadingReaders();
            //将偏好设置为true，让写线程获取更多机会
            readWriteLockImp.setPreferWriter(true);
            //唤醒挂起中的writer线程
            readWriteLockImp.getMUTEX().notifyAll();
        }
    }
}

写锁的实现：

public class WriteLock implements Lock {
    private ReadWriteLockImp readWriteLockImp;

    public WriteLock(ReadWriteLockImp readWriteLockImp){
        this.readWriteLockImp = readWriteLockImp;
    }
    @Override
    public void lock() throws InterruptedException {
        synchronized (readWriteLockImp.getMUTEX()){
            //此时让等待写锁的线程数量+1
            try {
                readWriteLockImp.incrementWaitingWriters();
                //如果当前正有读线程在运行，或者有写线程运行，则挂起
                while (readWriteLockImp.getReadingReaders()>0
                        || readWriteLockImp.getWritingWriters()>0){
                    readWriteLockImp.getMUTEX().wait();
                }
            }finally {
                //获取了写锁，等待-1
                readWriteLockImp.decrementWaitingWriters();
            }
            //正在写入加1
            readWriteLockImp.incrementWritingWriters();
        }
    }

    @Override
    public void unlock() {
        synchronized (readWriteLockImp.getMUTEX()){
            //写入线程数量-1
            readWriteLockImp.decrementWritingWriters();
            //写偏好改为false,让读线程更多机会
            readWriteLockImp.setPreferWriter(false);
            readWriteLockImp.getMUTEX().notifyAll();
        }
    }
}

读写锁实现成功，来看一看具体使用

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.TimeUnit;
import java.util.stream.IntStream;

//读写锁的使用
public class ShareData {
    //定义共享数据源
    private final List<Character> container = new ArrayList<>();
    //构造ReadWriteLock
    private final ReadWriteLock readWriteLock = ReadWriteLock.readWriterLock();
    //创建读锁
    private final Lock readLock = readWriteLock.readLock();
    //创建写锁
    private final Lock writeLock = readWriteLock.writeLock();
    private final int length;

    public ShareData(int length) {
        this.length = length;
        IntStream.range(0, length).forEach(i -> {
            container.add(i, 'a');
        });
    }

    public char[] read() throws InterruptedException {
        try {
            //创建读锁
            readLock.lock();
            char[] newBuffer = new char[length];
            IntStream.range(0, length).forEach(i -> {
                newBuffer[i] = container.get(i);
            });
            slowly();
            return newBuffer;
        } finally {
            //解锁
            readLock.unlock();
        }
    }

    public void write(char a) throws InterruptedException {
        try {
            writeLock.lock();
            IntStream.range(0, length).forEach(i -> {
                container.add(i, a);
            });
            slowly();
        } finally {
            writeLock.unlock();
        }
    }

    //模拟读取时间
    private void slowly() {

        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

如果您发现该资源为电子书等存在侵权的资源或对该资源描述不正确等，可点击“私信”按钮向作者进行反馈；如作者无回复可进行平台仲裁，我们会在第一时间进行处理！

评价 0 条

相关资源

  • 面试官：Spring 用了哪些设计模式？说三种即可 2023-12-28 48358 浏览

    关于设计模式，如果使用得当，将会使我们的代码更加简洁，并且更具扩展性。本文主要讲解Spring中如何使用策略模式，工厂方法模式以及Builder模式。

  • 多线程（七）：单例设计模式 2023-12-28 53200 浏览

    单例模式：解决一个类再内存中只存在一个对象。共享对象。 想要保证对象唯一。 1。。。为了避免该类过多的创建对象，那么就私有构造方法 2。。。但是还要让其他程序可以访问该类，那么只好在本类中自定义一个对象， 3。。。为了方便其他程序对自定义对象的访问，可以对外提供一些访问方式

  • Spring框架中的设计模式(三) 2023-12-28 52479 浏览

    在之前的两篇文章中，我们看到了一些在Spring框架中实现的设计模式。这一次我们会发现这个流行框架使用的3种新模式。 本文将从描述两个创意设计模式开始：原型和对象池。最后我们将重点关注行为模式—>观察者。

  • Spring框架中的设计模式(一) 2023-12-28 50234 浏览

    设计模式有助于遵循良好的编程实践。作为最流行的Web框架之一的Spring框架也使用其中的一些。 本文将介绍Spring Framework中使用的设计模式。这是5篇专题文章的第一部分。这次我们将发现Spring框架中使用的4种设计模式：解释器，构建器，工厂方法和抽象工厂。每部分将首先解释给定模式的原理。紧接着，将会使用Spring的一个例子来加深理解。

  • iozone磁盘读写测试工具(操作系统) 2024-04-17 49470 浏览

    IOzone是一种广泛使用的文件系统基准测试工具，用于评估计算机系统在文件I/O方面的性能。它可以测试文件系统的读取、写入、重复读取、倒序读取、随机读取、跳跃读取等不同模式下的性能，并生成详细的测试报告。 测试模式： 顺序读取（SequentialRead）：按顺序读取文件内容，评估文件系统在大文件读取时的性能。 顺序写入（SequentialWrite）：按顺序写入文件内容，评估文件系统在大文件写入时的性能。 随机读取（RandomRead）：随机读取文件内容，评估文件系统在随机读取场景下的性能。 随机写入（RandomWrite）：随机写入文件内容，评估文件系统在随机写入场景下的性能。 重复读取（Re-Read）：重复读取文件内容，评估文件系统在缓存失效时的性能。 倒序读取（BackwardsRead）：倒序读取文件内容，评估文件系统在非顺序访问时的性能。 跳跃读取（StrideRead）：跳跃读取文件内容，评估文件系统在随机访问时的性能。 配置选项： 文件大小（FileSize）：设置测试文件的大小，以便评估文件系统在不同大小文件上的性能。 块大小（BlockSize）：设置每个I/O操作的块大小，以模拟不同的I/O请求。 线程数（NumberofThreads）：设置并发执行的线程数量，以测试文件系统在多线程访问时的性能。 测试时间（TestDuration）：设置测试的持续时间，以评估文件系统在长时间运行时的性能表现。 测试结果： IOzone会生成详细的测试报告，包括各种性能指标的统计数据、图表和摘要信息。 测试报告会显示各种测试模式下的吞吐量、IOPS（每秒I/O操作数）、延迟等性能指标，帮助用户全面了解文件系统的性能表现。 跨平台支持： IOzone可以在多种操作系统平台上运行，包括Linux、Windows、Unix等，使得用户可以在不同的环境中进行文件系统性能测试。

  • Spring框架中的设计模式(五) 2023-12-28 48699 浏览

    Spring框架中的设计模式(五)通过以前的4篇文章，我们看到Spring采用了大量的关于创建和结构方面的设计模式。 本文将描述属于行为方面的两种设计模式：命令和访问者。

  •  读写分离集群模式  2023-12-27 50329 浏览

    数据库服务器采用读写分离集群模式，可以满足对可用性有特殊需求的应用，具备以下特点：

  • Spring框架中的设计模式(四) 2023-12-28 48714 浏览

    本文是Spring框架中使用的设计模式第四篇。本文将在此呈现出新的3种模式。 一开始，我们会讨论2种结构模式：适配器和装饰器。在第三部分和最后一部分，我们将讨论单例模式。

  • Spring框架中的设计模式(二) 2023-12-28 49886 浏览

    在上一篇中我们在Spring中所谈到的设计模式涉及到了创建模式三剑客和1个行为模式(解释器模式)。这次我们会将眼光更多地关注在具有结构性和行为性的设计模式上。 在这篇文章中，我们将看到每个类型的两种模式。首先将关注类型是的结构设计模式。它将包含代理和复合。下一个将介绍行为模式：策略和模板方法。

  • 设计模式： 2023-12-26 51431 浏览

    设计模式： 四要素：模式名称、问题、解决方案、效果 创建型设计模式，抽象了实例化过程，帮助一个系统独立于如何创建、组合、表示它那些对象。

prtyaa
prtyaaL2
粉丝 1 资源 1949 + 关注 私信
最近热门资源
银河麒麟桌面操作系统备份用户数据  125
统信桌面专业版【全盘安装UOS系统】介绍  120
银河麒麟桌面操作系统安装佳能打印机驱动方法  112
银河麒麟桌面操作系统 V10-SP1用户密码修改  105
最近下载排行榜
银河麒麟桌面操作系统备份用户数据 0
统信桌面专业版【全盘安装UOS系统】介绍 0
银河麒麟桌面操作系统安装佳能打印机驱动方法 0
银河麒麟桌面操作系统 V10-SP1用户密码修改 0
作者收入月榜
1

prtyaa 收益393.62元

2

zlj141319 收益218元

3

1843880570 收益214.2元

4

IT-feng 收益209.03元

5

风晓 收益208.24元

6

777 收益172.71元

7

Fhawking 收益106.6元

8

信创来了 收益105.84元

9

克里斯蒂亚诺诺 收益91.08元

10

技术-小陈 收益79.5元

请使用微信扫码

加入交流群

请使用微信扫一扫!