标签：
读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM控制的，我们只要上好相应的锁即可。
如果你的代码只读数据，可以很多人同时读，但是不能同时写，那就上读锁；如果代码修改数据，只能一个人在写，且不能同时读取，
那就上写锁。总之，读的时候上读锁，写的时候上写锁。
java.util.concurrent.lock
Interface ReadWriteLock
实现类：
ReentrantReadWriteLock
ReadWriteLock实现了两把锁，一把只能进行读操作，一把进行写操作。读锁能够被多个线程拥有，写锁具有排他性。
所有ReadWriteLock的实现必须保证写锁操作对于读锁操作内存的同步（当然拥有写锁时具有排他性，此时只要保证写操作的内存对读操作
保持可见性就可以了，当然也就是所谓的同步了）。通俗点说，一个成功获得读锁的线程能够看到所有先前释放的写锁的更新。
读写锁比相互排它锁支持更大的并发量。它利用的一个事实是：同一时间只能有一个线程对共享数据进行更新，但是可以有多个线程对它进行读取。
读写锁的实现当然要比互斥锁的实现更难。此时，我们的应用到底是选择互斥锁还是读写锁，取决于我们应用读写操作发生的频率。如果读操作是频繁
发生的，而写操作不那么频繁，那么可以选择读写锁，这样会提高应用的性能；反之，如果我们的应用写操作比较频繁而读操作不那么频繁，并且读操作
是一些短时间的操作，那么就没有必要用到读写锁。
利用ReentrantReadWriteLock实现缓存：
1 class CachedData { 2 Object data; 3 volatile boolean cacheValid; 4 ReentrantReadWriteLock rwl=new ReentrantReadWriteLock(); 5 6 void processCachedData() { 7 rwl.readLock().lock(); 8 if(!cacheValid) { 9 //在获得写锁之前必须释放读锁 10 rwl.readLock().unlock(); 11 rwl.writeLock().lock(); 12 13 //再次检测状态，因为其他线程有可能获得 14 //写锁并且在我们操作之前改变了状态 15 if(!cacheValid) { 16 //data=....; 17 cacheValid=true; 18 } 19 //在释放写锁之前通过获得读锁进行降级 20 rwl.readLock().lock(); 21 rwl.writeLock().unlock();//释放写锁仍然拥有读锁 22 } 23 use(data); 24 rwl.readLock().unlock(); 25 } 26 }
利用ReentrantReadWriteLock提供集合的并发性能：
1 class RWDictionary { 2 private final Map<String,Data> m=new TreeMap<String,Data>(); 3 private final ReentrantReadWriteLock rwl=new ReentrantReadWriteLock(); 4 private final Lock r=rwl.readLock(); 5 private final Lock w=rwl.writeLock(); 6 7 public Data get(String key) { 8 r.lock(); 9 try { 10 return m.get(key); 11 }finally { 12 r.unlock(); 13 } 14 } 15 16 public String[] allKeys() { 17 r.lock(); 18 try { 19 return (String[])m.keySet().toArray(); 20 }finally { 21 r.unlock(); 22 } 23 } 24 25 public Data put(String key,Data value) { 26 w.lock(); 27 try { 28 return m.put(key, value); 29 }finally { 30 w.unlock(); 31 } 32 } 33 34 public void clear() { 35 w.lock(); 36 try { 37 m.clear(); 38 }finally { 39 w.unlock(); 40 } 41 } 42 }
标签：
原文地址：http://www.cnblogs.com/feijishuo/p/4535027.html
