读取锁分离设计模

最新推荐文章于 2024-08-14 23:12:09 发布

a xiang

最新推荐文章于 2024-08-14 23:12:09 发布

阅读量26

点赞数

文章标签： java spring boot jvm

本文链接：https://blog.csdn.net/sgx223534/article/details/134166764

版权

文章讲述了在多线程环境下，如何使用Java的ReentrantReadWriteLock进行资源同步，区分读写冲突，以及Lock接口的使用和ReadWriteLock的实现原理。重点介绍了ReadLock和WriteLock的获取和释放策略，以及如何通过preference控制读写优先级。

摘要由CSDN通过智能技术生成

再多线程的情况下访问共享资源，需要对资源进行同步操作以防止数据不一致的情况发生，通常我们可以使用synchroized关键字或者显式锁。
对资源的访问一般包括两种类型的动作–读和写，如果多个线程在某个时刻都在进行资源的读操作，虽然有资源的竞争，但是这种竞争不足以引起数据不一致的情况发生，那么这个时候采用排他的方式加锁。就显得有些简单粗暴了。除了多线程在同一时间都进行读操作时不会引起冲突之外，其余的情况都会导致访问的冲突，需要对资源进行同步处理
共享资源在多个线程中同时进行读操作不会引起冲突

线程	读	写
读	不冲突	冲突
写	冲突	冲突

如果对某个资源读的操作明显多过于写的操作，那么多线程读时并不操作，很明显对程序性能的提升会有很大的帮助，

接口定义

Lock接口定义

public interface Lock {
    //获取显示锁，没有获得锁的线程将阻塞
    void lock() throws InterruptedException;
    //释放获取的锁
    void unlock();
}

Lock接口定义了锁的基本操作，加锁和解锁，显示锁的操作强烈建议与 try finally语句快仪器室哟哦那个，加锁和解锁说明如下。
.lock():当前线程尝试获得锁的拥有权，在此期间有可能进入阻塞
.unlock: 释放锁，其主要目的就是为了减少reader或者writer的数量

ReadWriter接口定义

ReadWriter接口定义的代码

public interface ReadWriterLock {
    //创建reader锁
    Lock readLock();
    //创建write锁
    Lock writeLock();
    //获取当前有多少线程正在执行写操作
    int getWritingWriters();
    //获取当前有多少线程正在等待获取读取写入锁
    int getWaitingWriters();
    //获取当前有多少线程正在等待获取reader锁
    int getReadingReaders();

    static ReadWriterLock readWriteLock(){
        return new ReadWriteLockImpl();
    }
    static ReadWriterLock readWriteLock(Boolean preferWriter){
        return new ReadWriteLockImpl(preferWriter);

    }
}

ReadWriteLock虽然名字中有lock,但是它并不是lock,它主要用于创建read lock和write lock的，并且提供了查询功能用于查询当前有多少个reader和writer以及waiting中的writer,根据我们在前文的复习，如果reader的个数大于0，那就意味着writer的个数等于0，反之writer的个数大于0（事实上writer最多只能为1），则reader的个数大于0.由于读和写，写和写之间都存在着冲突，因此这样的数字关系也就不奇怪了

readlock():该方法主要用来获得一个ReadLock
writeLock():同readLock类似，该方法用来获得writeLock
getWritingWriters(): 获取当前有多少线程正在执行写操作,最多为1个
getWaitingWriters:()获取当前有多少个线程由于获得写锁而导致阻塞
getReadingReaders():获取当前有多少个线程正在进行的读操作

程序实现

ReadWriteLockImpl

相当于Lock,ReadWriteLockImpl更像是一个工厂累，可以通过它创建不同类型的锁，我们将ReadWriteLockImok设计为包可见的类，其主要目的是不想对外保罗更多的细节，在ReadWriteLockImpl中还对一了非常多的包可见方法

package com.ax.frame.thread.chapter1;

import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * @Author sgx
 * @Description TODO
 * @Date 2023/11/1 10:50
 */
public class ReadWriteLockImpl  implements ReadWriterLock {
    //定义对象锁
    private final Object MUTEX = new Object();
    //当前多少个线程正在写入
    private int writingWriters = 0;
    //当前有多少线程正在等待写入
    private int waitingWriters = 0;
    //当前有多少个线程正在read
    private int readingReaders = 0;
    //read和write的偏好设置
    private Boolean preferWriter;
    //默认情况下preferWriter
    public ReadWriteLockImpl() {
        this(true);
    }
    //构造ReadWriteLockImpl并且传入preferWriter
    public ReadWriteLockImpl(Boolean preferWriter) {
        this.preferWriter = preferWriter;
    }

    //创建read lock
    @Override
    public Lock readLock() {
        return new ReadLock(this);
    }
    //创建write lock
    @Override
    public Lock writeLock() {
        return new WriteLock(this);
    }

    //获取当前有多少线程正在进行写操作
    @Override
    public int getWritingWriters() {
        return this. writingWriters;
    }
    //获取当前有多少线程正在等待获取写入锁
    @Override
    public int getWaitingWriters() {
        return this.waitingWriters;
    }
    //获取当前有多少线程正在进行读操作
    @Override
    public int getReadingReaders() {
        return this.readingReaders;
    }

    //使写线程的数量增加
    void incrementWritingWriters() {
        this.writingWriters++;
    }

    //使等待写入的线程数量增加
    void incrementWaitingWriters() {
        this.waitingWriters++;
    }

    //使读线程的数量增加
    void incrementReadingReaders() {
        this.readingReaders++;
    }

    //使写线程的数量减少
    void decrementWritingWriters() {
        this.writingWriters--;
    }

    //使等待获取写入锁的数量减一
    void decrementWaitingWriters() {
        this.waitingWriters--;
    }

    //使读取线程的数量减少
    void decrementReadingReaders() {
        this.readingReaders--;
    }
     //获取对象锁
    public Object getMUTEX() {
        return MUTEX;
    }
    //获取当前是否偏向写锁
    public Boolean getPreferWriter() {
        return preferWriter;
    }
    //设置写锁偏好
    void changePrefer(Boolean preferWriter){
        this.preferWriter=preferWriter;
    }
}

Object MUTEX：这是一个对象锁，用于同步访问共享资源。
int writingWriters：表示当前有多少个线程正在进行写操作。
int waitingWriters：表示当前有多少个线程正在等待获取写入锁。
int readingReaders：表示当前有多少个线程正在进行读操作。
Boolean preferWriter：表示读写的偏好设置，即是否偏向写锁。
ReadWriteLockImpl()：默认构造函数，会将偏好设置为偏向写锁。
ReadWriteLockImpl(Boolean preferWriter)：允许传入偏好设置的构造函数。
readLock()：创建一个读锁对象。
writeLock()：创建一个写锁对象。
getWritingWriters()：获取当前有多少线程正在进行写操作。
getWaitingWriters()：获取当前有多少线程正在等待获取写入锁。
getReadingReaders()：获取当前有多少线程正在进行读操作。
incrementWritingWriters()、incrementWaitingWriters()、incrementReadingReaders()：分别使写线程、等待写入的线程、读线程的数量增加。
decrementWritingWriters()、decrementWaitingWriters()、decrementReadingReaders()：分别使写线程、等待写入的线程、读线程的数量减少。
getMUTEX()：获取对象锁。
getPreferWriter()：获取当前是否偏向写锁。
changePrefer(Boolean preferWriter)：用于修改写锁的偏好设置。

虽然我们在开发一个读写锁，但是在实现的内部也需要一个锁进行数据同步以及线程之间的通信，其中MUTEX的作用就在于此**，**而preferWriter的作用在于控制倾向性，一般来说读写锁非常适用于读多写少的场景，如果preferWriter为false,很多读线程都在读数据，那么写线程将会很难得到机会。

当 preferWriter 为 true 时，意味着偏向写锁。这意味着系统会倾向于给予写线程更多的机会去获取锁，即使有读线程在等待。这可以提高写线程的响应速度，但可能会降低读线程的响应速度。
当 preferWriter 为 false 时，意味着不偏向写锁。在这种情况下，系统会平等对待读线程和写线程，不会倾向于给予任何一方更多的机会去获取锁。

ReadLock

读锁是lock的实现，

public class ReadLock implements Lock {
    private final ReadWriteLockImpl readWriteLock;

    public ReadLock(ReadWriteLockImpl readWriteLock) {
        this.readWriteLock = readWriteLock;
    }


    @Override
    public void lock() throws InterruptedException {
        //使用Mutex作为锁
        synchronized (readWriteLock.getMUTEX()){
            //若此时有线程在进行写操作，
            //或者写线程在等待并且偏向写锁的表示为true时，
            //就会无法获得读锁，只能被挂起
            while (readWriteLock.getWritingWriters()>0||
                   (readWriteLock.getPreferWriter()&&
                    readWriteLock.getWaitingWriters()>0)){
                readWriteLock.getMUTEX().wait();
            }
            readWriteLock.incrementReadingReaders();
        }

    }

    @Override
    public void unlock() {
        //使用Mutex作为锁，并且进行同步
        synchronized (readWriteLock.getMUTEX()){
            //释放锁的过程就是使得当前reading的数量减一
            //将preferWriterWriter设置为true,可以使得writer线程获得更多的机会
            //通知唤醒与Mutex关联monitor,waitSet重的线程
            readWriteLock.decrementReadingReaders();;
            readWriteLock.changePrefer(true);
            readWriteLock.getMUTEX().notifyAll();
        }

    }
}

当没有任何线程对数据进行写操作的时候，读线程才有可能获得锁的拥有权，当然除此之外，为了公平起见，如果当前有很多线程正在等待获得写锁的拥有权，同样读线程将会进入Mutex的wait set中，reading的数量将增加
读线程释放锁，这就意味着reader的数量将减少一个，同时唤醒wait中的线程，reader唤醒的基本上都是由于获取写锁而进入阻塞的线程，为了提供写锁获得锁的机会，需要将preferwriter修改为true

WriteLock

写锁是lock的实现，同样将其设计成包可见以透明其实现细节，让使用者只用专注于对接口的钓鱼哦那个，由于写–写冲突的存在，同一时间只能有一个线程获得锁的使用权，

public class WriteLock implements Lock {
    private ReadWriteLockImpl readWriteLock;

    public WriteLock(ReadWriteLockImpl readWriteLock) {
        this.readWriteLock = readWriteLock;
    }

    @Override
    public void lock() throws InterruptedException {
        synchronized (readWriteLock.getMUTEX()){
            try {

                //首先是等待获取写入锁的数组加一
                readWriteLock.incrementWritingWriters();
                //如果此时有其他线程正在进行读操作，或者写操作，那么当前线程将被挂起
                while (readWriteLock.getReadingReaders()>0||readWriteLock.getWritingWriters()>0){
                    readWriteLock.getMUTEX().wait();
                }
            }finally {
                //成功获取到了写入锁，使得当前获取写入锁的计数器减一
                this.readWriteLock.decrementWaitingWriters();
            }
            readWriteLock.incrementReadingReaders();

        }

    }

    @Override
    public void unlock() {
        synchronized (readWriteLock.getMUTEX()){
            //释放锁的过程就是使得当前reading的数量减一
            //将preferWriter设置为true,可以使得writer线程获得更多的机会
            //通知唤醒与Muter关联monitor,waitSet中的线程
            readWriteLock.decrementReadingReaders();
            readWriteLock.changePrefer(false);
            readWriteLock.getMUTEX().notifyAll();
        }

    }
}

当线程在进行读操作或者写操作的时候，若当前线程试图获得锁，则其将会进入MUTEx的wait set中而阻塞，同时增加waitingWriter和writingWriter的数量，但是当线程从wait set中被激活的时候waitingWriter将很快被减少
写释放锁，意味着writer的数量减少，事实上变成了0，同时唤醒waiter中的线程，并将preferWriter修改为false,以提高读线程获的锁的机会

lock() 方法：这是实现 Lock 接口的方法之一。在 lock() 方法中，首先使用 synchronized 语句块获取了 readWriteLock 的锁对象 MUTEX。然后，通过 try-finally 块确保在任何情况下都会将等待写入的线程计数器减一。接着，通过一个 while 循环判断是否满足获取写锁的条件，如果不满足，则调用 wait() 方法挂起线程，直到满足条件才能继续执行。最后，如果成功获取了写锁，调用 incrementReadingReaders() 增加正在读取的读线程数量。
unlock() 方法：这是实现 Lock 接口的方法之一。在 unlock() 方法中，同样使用 synchronized 语句块获取了 readWriteLock 的锁对象 MUTEX。然后，调用 decrementReadingReaders() 减少正在读取的读线程数量。接着，调用 changePrefer(false) 设置偏好写锁为 false，以便让读线程有更多的机会获取锁。最后，通过 notifyAll() 方法通知所有等待在 MUTEX 上的线程，以便唤醒它们。

读写锁的使用

package com.ax.frame.thread.chapter1;

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

/**
 * @Author sgx
 * @Description TODO
 * @Date 2023/11/1 15:51
 */
public class ShareData {
    //定义共享变量
    private final List<Character> characters=new ArrayList<>();
    //构造ReadWriteLock
    private final ReadWriterLock readWriterLock=ReadWriterLock.readWriteLock();
    //创建读取锁
    private final Lock readLock=readWriterLock.readLock();
    //创建写入锁
    private final Lock writeLock= readWriterLock.writeLock();
    private final int length;


    public ShareData(int length) {
        this.length = length;
        for (int i = 0; i < length; i++) {
            characters.add(i,'C');
        }
    }
    public char[] read() throws InterruptedException{
        try {
            //首先使用读锁进行lock
            readLock.lock();
            char[] newBuffer = new char[length];
            for (int i = 0; i < length; i++) {
                newBuffer[i]=  characters.get(i);
            }
            slowly();
            return newBuffer;

        }finally {
            //当操作结束之后，将锁释放
            writeLock.unlock();
        }
    }
    public void write(char c) throws InterruptedException{
        try {
            //首先使用读锁进行lock
            readLock.lock();
            for (int i = 0; i < length; i++) {
               this.characters.add(i,c);
            }
            slowly();
        }finally {
            //当操作结束之后，将锁释放
            writeLock.unlock();
        }
    }
    //简单模拟操作的耗时
    private void slowly() {
        try {
            TimeUnit.SECONDS.sleep(1);
        } catch (InterruptedException e) {
           e.printStackTrace();
        }
    }
}

public char[] read() throws InterruptedException：读操作方法。首先获取读锁，然后将列表中的字符复制到新的字符数组中，最后返回新的字符数组。
public void write(char c) throws InterruptedException：写操作方法。首先获取写锁，然后将指定的字符添加到列表中。
private void slowly()：模拟操作的耗时，让线程休眠1秒钟。

ShareData中涉及了对数据的读写操作，因此他是需要进行线程同步控制的，首先，创建一个ReadWriteLock工厂类。然后用该工厂分别创建ReadLock和Writelock的实例，在read方法中使用ReadLocck对其进行加锁，而在write方法中则使用writeLock,

public class ReadWriterLockTest {
    private final static String text="Thisistheexampleforreadwritelock";

    public static void main(String[] args) {
        //定义共享数据
        ShareData shareData = new ShareData(50);
        //创建两个线程进行数据写操作
        for (int i = 0; i < 2; i++) {
            new Thread(()->{
                for (int index = 0; index < text.length(); index++) {
                    try {
                        char c = text.charAt(index);
                        shareData.write(c);
                        System.out.println(Thread.currentThread()+"write"+c);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                while (true){
                    try {
                        System.out.println(Thread.currentThread()+"read"+new String(shareData.read()));
                    } catch (InterruptedException e) {
                          e.printStackTrace();
                    }

                }
            }).start();
        }
    }

}

Thread[Thread-1,5,main] write s
Thread[Thread-4,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-3,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-9,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-11,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-7,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-6,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-10,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-5,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-8,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-2,5,main] read ssssssssssssssssssssssssssssssssssssssssssssssssss
Thread[Thread-0,5,main] write h
Thread[Thread-6,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-7,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-9,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-5,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-8,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-4,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-11,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-3,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-2,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
Thread[Thread-10,5,main] read hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

a xiang

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
读取锁分离设计模

/获取显示锁，没有获得锁的线程将阻塞//释放获取的锁Lock接口定义了锁的基本操作，加锁和解锁，显示锁的操作强烈建议与 try finally语句快仪器室哟哦那个，加锁和解锁说明如下。.lock():当前线程尝试获得锁的拥有权，在此期间有可能进入阻塞.unlock: 释放锁，其主要目的就是为了减少reader或者writer的数量ReadWriter接口定义的代码//创建reader锁//创建write锁//获取当前有多少线程正在执行写操作。
复制链接

扫一扫