java多线程设计模式详解之四

ReadWriteLock

　　　  多线程读写同一个对象的数据是很普遍的，通常，要避免读写冲突，必须保证任何时候仅有一个线程在写入，有线程正在读取的时候，写入操作就必须等待。简单说，就是要避免“写-写”冲突和“读-写”冲突。但是同时读是答应的，因为“读-读”不冲突，而且很安全。

　 要实现以上的ReadWriteLock，简单的使用synchronized就不行，我们必须自己设计一个ReadWriteLock类，在读之前，必须先获得“读锁”，写之前，必须先获得“写锁”。举例说明：

DataHandler对象保存了一个可读写的char[]数组：

package com.crackj2ee.thread;

public class DataHandler {
　  // store data:
　  PRivate char[] buffer = "AAAAAAAAAA".toCharArray();

　  private char[] doRead() {
　　　  char[] ret = new char[buffer.length];
　　　  for(int i=0; i　　　　　  ret[i] = buffer[i];
　　　　　  sleep(3);
　　　  }
　　　  return ret;
　  }

　  private void doWrite(char[] data) {
　　　  if(data!=null) {
　　　　　  buffer = new char[data.length];
　　　　　  for(int i=0; i　　　　　　　  buffer[i] = data[i];
　　　　　　　  sleep(10);
　　　　　  }
　　　  }
　  }

　  private void sleep(int ms) {
　　　  try {
　　　　　  Thread.sleep(ms);
　　　  }
　　　  catch(InterruptedException ie) {}
　  }
}

doRead()和doWrite()方法是非线程安全的读写方法。为了演示，加入了sleep()，并设置读的速度大约是写的3倍，这符合通常的情况。

为了让多线程能安全读写，我们设计了一个ReadWriteLock：

package com.crackj2ee.thread;
public class ReadWriteLock {
　  private int readingThreads = 0;
　  private int writingThreads = 0;
　  private int waitingThreads = 0; // waiting for write
　  private boolean preferWrite = true;

　  public synchronized void readLock() throws InterruptedException {
　　　  while(writingThreads>0 (preferWrite && waitingThreads>0))
　　　　　  this.wait();
　　　  readingThreads++;
　  }

　  public synchronized void readUnlock() {
　　　  readingThreads--;
　　　  preferWrite = true;
　　　  notifyAll();
　  }

　  public synchronized void writeLock() throws InterruptedException {
　　　  waitingThreads++;
　　　  try {
　　　　　  while(readingThreads>0 writingThreads>0)
　　　　　　　  this.wait();
　　　  }
　　　  finally {
　　　　　  waitingThreads--;
　　　  }
　　　  writingThreads++;
　  }

　  public synchronized void writeUnlock() {
　　　  writingThreads--;
　　　  preferWrite = false;
　　　  notifyAll();
　  }
}