读写锁问题也是比较常见的问题，这是因为现实中充斥着这类问题，而读者写者问题是单纯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
?
??? 最后，值得提醒的是，类似这样的问题都能抽象出一个共同的特征：那就是读线程比较多或者读操作比较繁重。如果大多数线程是写操作的话，就得评估衡量用读写锁来解决是否合算了。