Read-Write Lock

原创
2016/04/27 22:28
阅读数 42

                                                                        Read-Write Lock

    当不同操作之间会对对象临界区造成不同区别的时候,可以考虑Read-Write锁模式,就是操作中有些会改变有些不会改变(有点绕,但只要理解了的应该可以懂)。

//读线程,共享Data
public class ReaderThread extends Thread {
	private final Data data;

	public ReaderThread(Data data) {
		this.data = data;
	}

	public void run() {
		try {
			while (true) {
				char[] readbuf;
				readbuf = data.read();
				System.out.println(getName() + String.valueOf(readbuf));
			}
		} catch (InterruptedException e) {
		}
	}
}
//写线程
public class WriterThread  extends Thread{
	private final Data data;
	private  final String filler;
	private int index=0;
	public WriterThread(Data data,String filler){
		this.data=data;
		this.filler=filler;
	}
	
	public void run(){
		try{
			while(true){
				char c=nextchar();
				data.write(c);
				sleep(1500);
			}
		}catch(InterruptedException e){
		}
	}
	private char nextchar(){
		char c=filler.charAt(index);
		index++;
		if(index>=filler.length()){
			index=0;
		}
		return c;
	}
}
public class Data {
	private final char[] buffer;
	private final ReadWriteLock lock = new ReadWriteLock();

	public Data(int size) {
		this.buffer = new char[size];
		for (int i = 0; i < size; i++) {
			buffer[i] = '*';
		}
	}

	public char[] read() throws InterruptedException {
		lock.readLock();
		try {
			return doRead();
		} finally {
			lock.readUnlock();
		}
	}

	private char[] doRead() {
		char[] newbuf = new char[buffer.length];
		for (int i = 0; i < buffer.length; i++) {
			newbuf[i] = buffer[i];
		}
		slowly();
		return newbuf;
	}

	public void write(char c) throws InterruptedException {
		lock.writeLock();
		try {
			doWrite(c);
		} finally {
			lock.writeUnlock();
		} 

	}
	public void doWrite(char c){
		for(int i=0;i<buffer.length;i++){
			buffer[i]=c;
			slowly();
		}
	}
	private void slowly() {
		try {
			Thread.sleep(50);
		} catch (InterruptedException e) {
		}
	}
}
//读写锁
public class ReadWriteLock {
	private int readingReaders = 0;
	private int waitingWriters = 0;
	private int writingWriters = 0;
	private boolean preferWriter = true;

	public synchronized void readLock() throws InterruptedException {
		while (writingWriters > 0 || (preferWriter && waitingWriters > 0)) {
			wait();
		}
		readingReaders++;
	}

	public synchronized void readUnlock() {
		readingReaders--;
		preferWriter = true;
		notifyAll();
	}

	public synchronized void writeLock() throws InterruptedException {
		waitingWriters++;
		try {
			while (readingReaders > 0 || writingWriters > 0) {
				wait();
			}
		} finally {
			waitingWriters--;
		}
		writingWriters++;

	}
	
	public synchronized void writeUnlock(){
		writingWriters--;
		preferWriter=false;
		notifyAll();
	}

}

    因为是写优先,所以读查看有时候会等待。

    最关键的:

        private int readingReaders = 0;//正在读的数量
	private int waitingWriters = 0;//等待写的数量
	private int writingWriters = 0;//正在写的数量
	private boolean preferWriter = true;//是否写优先

    为了解决的就是两个冲突问题: 1.读写冲突     2.写写冲突

    在获取读锁情况下会发生的情况,在获取写锁会发生的情况。只要理清楚,就知道怎么写了。

    这个模式适合的是既有写操作又有读操作,而且读操作比写操作频繁,甚至读操作还是比较费时间的情况下,因为不费时间,还不如single thread execution。

       

        

展开阅读全文
打赏
1
4 收藏
分享
加载中
更多评论
打赏
0 评论
4 收藏
1
分享
返回顶部
顶部