读写锁分离设计模式

最新推荐文章于 2025-02-06 18:27:26 发布

原创最新推荐文章于 2025-02-06 18:27:26 发布 · 392 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式 #Java

Java基础专栏收录该内容

19 篇文章

订阅专栏

场景描述：

在多线程的情况下访问共享资源，需要对资源进行同步操作以防止数据不一致的情况发生，通常我们可以使用synchronized关键字或者显示锁。

对资源的访问一般包括两种类型的动作——读和写（更新、删除、增加等资源会发生变化的动作），如果多个线程在某个时刻都在进行资源的读操作，虽然有资源的竞争，但是这种竞争不足以引起数据不一致的情况发生，那么这个时候直接采用排他的方式加锁，就显得有些简单粗暴了。除了多线程在同一时间都进行读操作时不会引起冲突之外，其余的情况都会导致访问的冲突，需要对资源进行同步处理。

Lock接口定义：

package MutilThreadModel.ReadWriteLockToSeperater;

/**
 * Created by JYM on 2019/1/10
 * */

//定义一个Lock接口
public interface Lock
{
    //获取显示锁，没有获得锁的线程将被阻塞
    void lock() throws InterruptedException;

    //释放获取的锁
    void unlock();
}

/**
 * Lock接口定义了锁的基本操作，加锁和解锁，显示锁的操作强烈建议与try finally语句块一起使用，加锁和解锁说明如下。
 * lock():当前线程获得锁的拥有权，在此期间有可能进入阻塞；
 * unlock():释放锁，其主要目的就是为了减少reader或者writer的数量。
 * */

ReadWriteLock接口定义：

package MutilThreadModel.ReadWriteLockToSeperater;

/**
 * Created by JYM on 2019/1/10
 * */
//定义ReadWriteLock接口
public interface ReadWriteLock
{
    //创建reader锁
    Lock readLock();

    //创建write锁
    Lock writeLock();

    //获取当前有多少线程正在执行写操作
    int getWritingWriters();

    //获取当前有多少线程正在等待获取写入锁
    int getWaitingWriters();

    //获取当前有多少线程正在等待获取reader锁
    int getReadingReaders();

    //工厂方法，创建ReadWriteLock
    static ReadWriteLock readWriteLock()
    {
        return new ReadWriteLockImpl();
    }

    //工厂方法，创建ReadWriteLock，并且传入preferWriter
    static ReadWriteLock 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，由于读和写，写和写之间都存在着冲突，因此这样的数字
 * 关系也就不奇怪了。
 * */


/**
 * 相对于Lock，ReadWriteLockImpl更像是一个工厂类，可以通过它创建不同类型的锁，
 * 我们将ReadWriteLockImpl设计为包可见的类，其主要目的是不想对外暴露更多的细节，
 * */
//包可见，创建时使用ReadWriteLock的create方法
class ReadWriteLockImpl implements ReadWriteLock
{
    //定义对象锁
    private final Object MUTEX = new Object();

    //当前有多少个线程正在写入
    private int writingWriters = 0;

    //当前有多少个线程正在等待写入
    private int waitingWriters = 0;

    //当前有多少个线程正在read
    private int readingReaders = 0;

    //read和write的偏好设置
    private boolean preferWriter;

    //默认情况下perferWriter为true
    public ReadWriteLockImpl()
    {
        this(true);
    }

    //构造ReadWriteLockImpl并且传入preferWriter
    public ReadWriteLockImpl(boolean preferWriter)
    {
        this.preferWriter = preferWriter;
    }

    //创建read lock
    public Lock readLock()
    {
        return new ReadLock(this);
    }

    //创建write lock
    public Lock writeLock()
    {
        return new WriteLock(this);
    }

    //使写线程的数量增加
    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 int getWritingWriters()
    {
        return this.writingWriters;
    }

    //获取当前有多少个线程正在等待获取写入锁
    public int getWaitingWriters()
    {
        return this.waitingWriters;
    }

    //获取当前有多少个线程正在进行读操作
    public int getReadingReaders()
    {
        return this.readingReaders;
    }

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

    //获取当前是否偏向写锁
    boolean getPreferWriter()
    {
        return this.preferWriter;
    }

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

//读锁是Lock的实现，同样将其设计为包可见以透明实现细节，让使用者只用专注于对接口的使用
class ReadLock implements Lock
{
    private final ReadWriteLockImpl readWriteLock;
    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();
            }

            //成功获得读锁，并且readingReaders的数量增加
            readWriteLock.incrementReadingReaders();
        }
    }

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

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

//写锁是Lock的实现，同样将其设计成包可见以透明其实现细节，使使用者只用专注于对接口的调用，由于写-写冲突的存在，同一时间只能有一个
//线程获得锁的拥有权。
class WriteLock implements Lock
{
    private final ReadWriteLockImpl readWriteLock;

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

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

    @Override
    public void unlock()
    {
        synchronized (readWriteLock.getMUTEX())
        {
            //减少正在写入锁的线程计数器
            readWriteLock.decrementWritingWriters();

            //将偏好状态修改为false,可以使得读锁被最快速的获得
            readWriteLock.changePrefer(false);
            //通知唤醒其他在MUTEX monitor waitset中的线程
            readWriteLock.getMUTEX().notifyAll();
        }
    }
}

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

读写锁的使用：

package MutilThreadModel.ReadWriteLockToSeperater;

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

/**
 * Created by JYM on 2019/1/10
 * 下面代码是关于读写锁的使用
 * */

public class ShareData
{
    //定义共享数据(资源)
    private final List<Character> container = new ArrayList<>();

    //构造读写锁
    private final ReadWriteLock readWriteLock = ReadWriteLock.readWriteLock();
    //创建读取锁
    private final Lock readLock = readWriteLock.readLock();

    //创建写入锁writeLocK
    private final Lock writeLock = readWriteLock.writeLock();
    private final int length;

    public ShareData(int length)
    {
        this.length = length;
        for (int i=0;i<length;i++)
        {
            container.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] = container.get(i);
            }
            slowly();
            return newBuffer;
        }finally {
            //当操作结束之后，将锁释放
            readLock.unlock();
        }
    }

    public void write(char c) throws InterruptedException
    {
        try{
            //使用写锁进行lock
            writeLock.lock();
            for (int i=0;i<length;i++)
            {
                this.container.add(i,c);
            }
            slowly();
        }finally {
            //当所有的操作都完成之后，对写锁进行释放
            writeLock.unlock();
        }
    }

    //简单模拟操作的耗时
    private void slowly()
    {
        try{
            TimeUnit.SECONDS.sleep(1);
        }catch (InterruptedException e)
        {
            e.printStackTrace();
        }
    }
}

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

测试：

package MutilThreadModel.ReadWriteLockToSeperater;

import static java.lang.Thread.currentThread;

/**
 * Created by JYM on 2019/1/10
 * */

public class ReadWriteLockTest
{
    //This is a example for read write lock
    private final static String text = "Thisisaexampleforreadwritelock";

    public static void main(String[] args)
    {
        //定义共享数据
        final 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(currentThread()+" write "+c);
                    }catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            },"第"+(i+1)+"个写线程").start();
        }

        //创建十个线程进行数据读操作
        for (int i=0;i<10;i++)
        {
            new Thread(()->{
                while (true)
                {
                    try{
                        System.out.println(currentThread()+" read "+new String(shareData.read()));
                    }catch (InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            }).start();
        }
    }
}

/**
 * 为了在读多于写的场景中体现读写锁，我们创建了10个读的线程和两个写的线程，上面的程序需要你借助于Ctrl+Break进行停止，虽然我们比较完整地
 * 完成了一个读写锁的设计并且可以投入使用，但是还是存在着一定的缺陷和一些需要补强的地方，比如可以结合BooleanLock的方式增加超时的功能，提供用于
 * 查询哪些线程被陷入阻塞的方法，判断当前线程是否被某个lock锁定等。
 * */