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。