Read-Write Lock

                                                                        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。