线程高级---读写锁

读写锁问题也是比较常见的问题，这是因为现实中充斥着这类问题，而读者写者问题是单纯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

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