线程高级---读写锁

读写锁问题也是比较常见的问题，这是因为现实中充斥着这类问题，而读者写者问题是单纯synchronized的进化版，之所以这么说，是因为它将锁分为读锁和写锁，通过读锁之间的并发性和写锁的排他性从而极大的提升性能。

    在开始之前，还是先来回顾一下读写锁问题。一个数据文件或记录能被多个线程共享。有些线程要求读，而另一些则要求写或修改。允许多个读线程同时读一个共享对象，因为读操作不会使数据文件混乱，但绝不允许一个写线程和其他读或写线程同时访问共享对象。因为这种访问违反了Bernstein条件。

    根据上面的描述，我们可以看出，读锁跟一般的互斥有些不一样，它只互斥写锁，但却不管读锁，换句话说，读锁之间是可以大量并发执行的。这样的例子随处可见，比如，机票售票系统，在买票高峰时期常常都是多个售票窗口同时查询，而不会发生多个人订了同一个座位或者说座位空着却不能订的情况。那么，读写锁在之间是如何发挥其并发的优越性的。当多个售票窗口同时查询时，由于是读取操作，可以同时执行，就是说大家都能看，而不是要排队一个一个看。而一旦有一个人订了票，则在读锁完全解除时，这个写锁就会将票mark为已经购买。之所以不会发生多人同订了一个座位，是因为读锁具有排他性，一旦有个读锁在修改，则不能有其它读锁同时修改。类似的例子还有很多，比如证卷交易等等（注意这里举的两个例子并非是线程的读写锁，通常情况下是利用了关系数据库的读写锁来提升并发性的，这里为了更通俗，从而举这两个常见的例子）

    下图是整个读写锁的框架，对这个框架有个概念性的认识，在复用时需要修改的是哪些？

   

    下面是一个应用读写锁的简单例子。每段程序会加以解读。

/**
 * 2007-6-19
 * Queue.java
 * package ReadWriteLock
 * TODO As a lock
 * levi
 */
package ReadWriteLock;

public class ReadWriteLock {
 private int readingReader;
 private int writingWriter; //0 or 1
 private int waitingWriter;
 private boolean tendWrite;
 
 public synchronized void lockReader(){
  while(writingWriter > 0 || (tendWrite && waitingWriter > 0)){
   try{
    wait();
   }
   catch(InterruptedException ie){
    
   }
  }
  readingReader++;
 }
 
 public synchronized void lockWriter() throws InterruptedException{
  waitingWriter++;
  try{
   while(readingReader > 0 || writingWriter > 0){
    wait();
   }
  }
  finally{
   waitingWriter--;
  }
  writingWriter++;
 }
 
 public synchronized void unlockReader(){
  readingReader--;
  tendWrite = true;
  notifyAll();
 }
 
 public synchronized void unlockWriter(){
  writingWriter--;
  tendWrite = false;
  notifyAll();
 }
}

     这里设置了4个变量readingReader，writingWriter，waitingWriter，tendWrite，分别代表正在读的读者，正在写的写者，等待中的写者以及一个用来评估读还是写的判断条件。这个评估条件是非常有用的，它能够保证程序不会只运行读线程（因为读的量较大），而是适当的让出一些机会给写线程。读锁定中while(writingWriter > 0 || (tendWrite && waitingWriter > 0)) 就是存在正在写的线程（意味着现在的机会在写线程手中）或者评估为写并且正在等待的写线程超过一个（意味着之后的机会应该给写线程）那就得等待。而写锁的等待条件则是while(readingReader > 0 || writingWriter > 0) 意味着有正在运行的读或写线程，则必须等待，这体现了写的排他性。而这里waitingWriter++;后面又 finally{waitingWriter--;}可能觉得很奇怪，怎么加一会减一会的，其实这里用到了线程设计的before/after pattern，只有当进入wait而没有发生任何错我们才知道它在等待，可惜我们没办法在wait里设置，于是before wait，我们就用了waitingWriter++;表示已经开始等待了，而无论是被中断取消或是正常唤醒，我们都要waitingWriter--; 表示结束。解锁就不在解释了，注意观察评估变量的设定及其作用。

/**
 * 2007-6-19
 * Queue.java
 * package ReadWriteLock
 * TODO As a shared concurrent resource
 * levi
 */
package ReadWriteLock;

import java.util.*;
/**
 * @author levi
 *
 */
public class Queue {
 private LinkedList queue = new LinkedList();
 private ReadWriteLock rwLock = new ReadWriteLock();

 public Queue(String str){
  StringTokenizer st = new StringTokenizer(str.toString());
  while(st.hasMoreTokens())
   queue.add(st.nextToken());
 }
 
 public Object read() throws InterruptedException{
  rwLock.lockReader();
  try{
   String s = "";
   for(int i = 0;i < queue.size();i++){
    s += queue.remove(0);
   }
   return s;
  }
  finally{
   rwLock.unlockReader();
  }
 }
 
 public void write(Object obj) throws InterruptedException{
  rwLock.lockWriter();
 
  try{
   StringTokenizer st = new StringTokenizer(obj.toString());
   while(st.hasMoreTokens())
    queue.add(st.nextToken());
  }
  finally{
   rwLock.unlockWriter();
  }
 }
}

     这个类是实际的资源类，主要就是read和write方法，read负责读出所有对象并将队列清空，而write负责写入对象。注意读写锁的使用。

     注意这里是通过两个逻辑上实现的lockReader和lockWriter来锁定程序，跟synchronized不同的是，这两个锁实际上用到了synchronized，只是比它多了些判读条件。

/**
 * 2007-6-19
 * Reader.java
 * package ReadWriteLock
 * TODO As a reader to read data concurrently from queue
 * levi
 */
package ReadWriteLock;

public class Reader extends Thread{
 
 private Queue queue;
 
 public Reader(Queue queue){
  this.queue = queue;
 }
 
 public void run(){
  try{
   System.out.println(Thread.currentThread().getName() + " Query: " + queue.read().toString());
  }
  catch(InterruptedException ie){
   
  }
 }
}

     Reader类。就是将read读入的内容显示出来。

 

/**
 * 2007-6-19
 * Writer.java
 * package ReadWriteLock
 * TODO As a writer to write data to queue
 * levi
 */
package ReadWriteLock;

public class Writer extends Thread{
 private Queue queue;
 private String request;
 
 public Writer(Queue queue,String request){
  this.queue = queue;
  this.request = request;
 }
 
 public void run(){
  try{
   queue.write(request);
  }
  catch(InterruptedException ie){
   
  }
 }
}

     Writer。负责写入一个request

 

/**
 * 2007-6-19
 * Test.java
 * package ReadWriteLock
 * TODO the main thread
 * levi
 */
package ReadWriteLock;

/**
 * @author levi
 *
 */
public class Test {
 public static void main(String [] args){
  Queue q = new Queue("* * * * * * * * * *");
  new Writer(q,"I find that I had fallen into you, beautiful girl").start();
  new Writer(q,"But also I am wasting my time,flower becomes air").start();
  new Reader(q).start();
  new Reader(q).start();
  new Reader(q).start();
  new Reader(q).start();
  new Reader(q).start();
  
 }
}

    主测试类。主要负责调用Reader和Writer

 

    最后，值得提醒的是，类似这样的问题都能抽象出一个共同的特征：那就是读线程比较多或者读操作比较繁重。如果大多数线程是写操作的话，就得评估衡量用读写锁来解决是否合算了。