适用于读多于写的情况
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;
}
}