高并发编程学习笔记(6)----读写分离设计模式

读写锁分离

在多线程的情况下访问共享资源，需要对资源进行同步操作以防止数据不一致的情况发生，通常我们可以使用synchronized关键字或者显示锁。
对资源的访问一般包括两种操作–读的写，但是多个资源在同时读取同步数据时并不会引起数据不一致的情况发生。那么这个时候采用排他的方式加锁就显得有些简单粗暴了。

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

当对某个资源读的操作明显多与写的操作时，那么多线程读时并不加锁，很明显会对程序性能有很大的提升。我们将来实现一个读写分离的锁。

定义接口

Lock接口

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

ReadWriteLock接口

该接口含有readLock锁和writeLock锁。这两个锁都实现了Lock接口

public interface ReadWriteLock {
    //创建reader锁
    Lock writeLock();
    //创建write锁
    Lock readLock();
    //获取当前有多少线程正在执行获取写入锁(1或0)
    int getWritingWriters();
    //获取当前有多少线程正在等待获取写入锁
    int getWaitingWriters();
    //获取当前有多少线程正在进行读操作
    int getReadingReaders();
    static ReadWriteLock readWriteLock(){
        return new ReadWriteLockImpl();
    }

    static ReadWriteLockImpl readWriteLock(boolean preferWrite){
        return new ReadWriteLockImpl(preferWrite);
    }
}

实现接口

public class ReadWriteLockImpl implements ReadWriteLock {
   //定义锁对象
   private final Object MUTEX = new Object();

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

    //定义有少的线程在等待写入
    private  int  waitingWriters =0;

    //定义当前有多少线程正在读
    private  int readingReaders=0;


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

    //默认情况下为true
    public ReadWriteLockImpl(){
        this(true);
    }
    public  ReadWriteLockImpl(boolean preferWrite){
        this.preferWrite=preferWrite;
    }

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


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

    //写线程数量增加
    void incrementWritingWriters(){
        this.waitingWriters++;
    }
    //等待写入的线程增加
    void incrementWaitingWriters(){
        this.writingWriters++;
    }
    //读线程数量增加
    void incrementReadingReaders(){
        this.readingReaders++;
    }
    //写线程数减少
    void decrementWritingWriters(){
        this.waitingWriters--;
    }
    //等待写入的线程减少
    void decrementWaitingWriters(){
        this.writingWriters--;
    }
    //读线程数量减少
    void decrementReadingReaders(){
        this.readingReaders--;
    }

    public int getWritingWriters() {
        return writingWriters;
    }

    public int getWaitingWriters() {
        return waitingWriters;
    }

    public int getReadingReaders() {
        return readingReaders;
    }

    public Object getMUTEX() {
        return MUTEX;
    }

    public boolean getPreferWrite() {
        return preferWrite;
    }
    void changePrefer(boolean preferWrite){
        this.preferWrite=preferWrite;
    }
}

ReadLock

//读数据锁，只与写数据锁互斥

public class ReadLock implements Lock {
    private  final ReadWriteLockImpl readWriteLock;

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

    @Override
    public void lock() throws InterruptedException {
        synchronized (readWriteLock.getMUTEX()){
            while (readWriteLock.getWaitingWriters()>0
                    ||(readWriteLock.getWaitingWriters()>0&&
                        readWriteLock.getPreferWrite())){
                readWriteLock.getMUTEX().wait();
            }
            readWriteLock.incrementReadingReaders();
        }
    }

    @Override
    public void unlock() {
        synchronized (readWriteLock.getMUTEX()){
            readWriteLock.decrementReadingReaders();
            readWriteLock.changePrefer(true);
            readWriteLock.getMUTEX().notifyAll();
        }
    }
}

WriteLock

写数据锁，与读锁和写锁都互斥。

public class WriteLock implements Lock{
    private ReadWriteLockImpl readWriteLock;

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

    @Override
    public void lock() throws InterruptedException {
        synchronized (readWriteLock.getMUTEX()){
            try {
                readWriteLock.incrementWaitingWriters();
                while (readWriteLock.getReadingReaders()>0
                        ||readWriteLock.getWaitingWriters()>0){
                    readWriteLock.getMUTEX().wait();
                }
            }finally {
                this.readWriteLock.decrementWaitingWriters();
            }
            readWriteLock.incrementWritingWriters();
        }
    }

    @Override
    public void unlock() {
        synchronized (readWriteLock.getMUTEX()){
            readWriteLock.decrementWritingWriters();
            readWriteLock.changePrefer(false);
            readWriteLock.getMUTEX().notifyAll();
        }
    }
}

ReadWriteLock虽然名字有Lock但它并不是一个锁，主要是用于创建readLock锁与writeLock锁并且提供查询当前有多少个reader、write和等待的write。
readLock、writeLock中又含有ReadWriteLock字段，主要是为了能够对MUTEX对象加锁。因为读、写是两个不同的实现类，他们需要对同一对象加锁。而且writeLock、readLock中加锁时需要调用ReadWriteLock中的方法进行判断有多少个reader、write和等待的write。并且加锁和释放锁还要对相应的reader、write和等待的write进行加操作或者减操作。

测试

定义读写操作

public class ShareData {
    private  final List<Character> container= new ArrayList<>();
    private  final  ReadWriteLock readWriteLock =ReadWriteLock.readWriteLock();
    private final  Lock readLock = readWriteLock.readLock();
    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{
            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(int index,char c) throws  InterruptedException{
        try{
            writeLock.lock();

                this.container.add(index,c);

            slowly();
        }finally {
            writeLock.unlock();
        }
    }

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

测试

public class ReadWriteLockTest {
    final  static String text ="Thisistheexampleforreadwritelock";

    public static void main(String[] args) {
        final ShareData shareData =new ShareData(50);
            new Thread(()->
            {
                for (int index = 0; index < text.length(); index++) {
                    try{
                        char c = text.charAt(index);
                        shareData.write(index,c);
                        System.out.println(currentThread()+" write "+c);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        for (int i = 0; i < 3; i++) {
            new Thread(()->{
                while(true)
                    try{
                        System.out.println(currentThread()+" read "+new String(shareData.read()));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
            }).start();
        }
    }
}

java.util.concurrent.locks.ReadWriteLock包下有ReadWriteLock。并且ReentrantReadWriteLock实现了ReadWriteLock锁