读写分离设计

适用于读多于写的情况

public interface Lock {

//获取显示锁，未能获取线程将堵塞

void lock() throws InterruptedException;

//释放获取的锁 减少read或者write的数量

void unlock();

}



public interface ReadWriteLock {

/**

*

* 读的数量大于0，意味着写的数量等于0

* 写的数量为1，意味着读的数量为0

*/

//创建reader锁

Lock readLock();



//创建Write锁

Lock write();



//获取当前有多少线程正在执行写操作

int getWritingWriters();



//获取当前有多少个线程正在等待写操作

int getWaitingWriters();



//获取当前有多少个线程正在等待读操作

int getReadingReaders();



//工厂方法创建ReadWriteLock

static ReadWriteLock readWriteLock(){

        //从接口实例化子类

      return new ReadWriteLockImpl();

}



//工厂方法创建ReadWriteLock

static ReadWriteLock readWriteLock(boolean preferWriter){

        //从接口实例化子类

        return new ReadWriteLockImpl(preferWriter);

}

}



public class WriteLock implements Lock{

private final ReadWriteLockImpl readWriteLock;



WriteLock(ReadWriteLockImpl readWriteLock){

this.readWriteLock = readWriteLock;

}



@Override

public void lock() throws InterruptedException {

        synchronized (readWriteLock.getMutex()){

            try {

                    //等待写的线程数加1

                readWriteLock.incrementWatingWriters();

                while(readWriteLock.getReadingReaders() > 0

                    || readWriteLock.getWritingWriters() > 0){

                readWriteLock.getMutex().wait();

                }

            }finally {

            //增加写的线程 //因为读锁会被prefer影响。所以防止程序一直无法获取到读锁

            this.readWriteLock.incrementWatingWriters();

            }

            this.readWriteLock.incrementWritingWriters();

}



}



@Override

public void unlock() {

         synchronized (readWriteLock.getMutex()){

            //减少正在写的线程

            readWriteLock.decrementWritingWriters();

            //将偏好修改为false，可以使得读锁被最快的获取

            readWriteLock.changePrefer(false);

           //通知唤醒其他在Mutext monitor waitset中的线程

          readWriteLock.getMutex().notifyAll();

        }

    }

}



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.getWritingWriters() >0 ||

                    (readWriteLock.getPreferWriter() && readWriteLock.getWaitingWriters()>0)){

            readWriteLock.getMutex().wait();

            }

            //成功获取到锁

            readWriteLock.incrementReadingReaders();

    }

}



@Override

public void unlock() {

        synchronized (readWriteLock.getMutex()){

        //释放锁的过程就是使得当前reading数量-1

        //将preferWriter设置为true,可以使得writer线程获得更多的机会

        //通知唤醒与Mutex关联monitor waitset中的线程

        readWriteLock.decrementReadingReaders();

        readWriteLock.changePrefer(true);

        readWriteLock.getMutex().notifyAll();

        }

    }

}



public class ReadWriteLockImpl implements ReadWriteLock{

//定义对象锁

private final Object MUTEX = new Object();



//多少个线程正在写

private int writingWriters = 0;



//多少个线程正在等待写

private int waittingWriters = 0;



//多少个线程正在等待读

private int readingReaders = 0;



//read和write偏好设置

private boolean preferWrite;



public ReadWriteLockImpl(){

this(true);

}



public ReadWriteLockImpl(boolean preferWrite){

this.preferWrite = preferWrite;

}



@Override

public Lock readLock() {

return new ReadLock(this);

}



@Override

public Lock write() {

return new WriteLock(this);

}



@Override

public int getWritingWriters() {

return this.writingWriters;

}



@Override

public int getWaitingWriters() {

return this.waittingWriters;

}



@Override

public int getReadingReaders() {

return this.readingReaders;

}



void incrementWritingWriters(){

this.writingWriters++;

}



void incrementWatingWriters(){

this.waittingWriters++;

}



void incrementReadingReaders(){

this.readingReaders++;

}



void decrementWritingWriters(){

this.writingWriters --;

}



void decrementWaitingWriters(){

this.waittingWriters --;

}



void decrementReadingReaders(){

this.readingReaders --;

}



Object getMutex(){

return this.MUTEX;

}



//是否偏向于写锁

boolean getPreferWriter(){

return this.preferWrite;

}



//设置锁偏好

void changePrefer(boolean preferWrite){

this.preferWrite = preferWrite;

}



}