7、ReadWriteLock

读写锁：分为读锁和写锁，多个读锁不互斥，读锁与写锁互斥，写锁与写锁互斥，这是由JVM控制的，我们只要上好相应的锁即可。

如果你的代码只读数据，可以很多人同时读，但是不能同时写，那就上读锁；如果代码修改数据，只能一个人在写，且不能同时读取，

那就上写锁。总之，读的时候上读锁，写的时候上写锁。

 

java.util.concurrent.lock

Interface ReadWriteLock

实现类：

ReentrantReadWriteLock

 

ReadWriteLock实现了两把锁，一把只能进行读操作，一把进行写操作。读锁能够被多个线程拥有，写锁具有排他性。

所有ReadWriteLock的实现必须保证写锁操作对于读锁操作内存的同步（当然拥有写锁时具有排他性，此时只要保证写操作的内存对读操作

保持可见性就可以了，当然也就是所谓的同步了）。通俗点说，一个成功获得读锁的线程能够看到所有先前释放的写锁的更新。

 

读写锁比相互排它锁支持更大的并发量。它利用的一个事实是：同一时间只能有一个线程对共享数据进行更新，但是可以有多个线程对它进行读取。

 

读写锁的实现当然要比互斥锁的实现更难。此时，我们的应用到底是选择互斥锁还是读写锁，取决于我们应用读写操作发生的频率。如果读操作是频繁

发生的，而写操作不那么频繁，那么可以选择读写锁，这样会提高应用的性能；反之，如果我们的应用写操作比较频繁而读操作不那么频繁，并且读操作

是一些短时间的操作，那么就没有必要用到读写锁。

 

利用ReentrantReadWriteLock实现缓存：

class CachedData {
    Object data;
    volatile boolean cacheValid;
    ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
    
    void processCachedData() {
        rwl.readLock().lock();
        if(!cacheValid) {
            //在获得写锁之前必须释放读锁
            rwl.readLock().unlock();
            rwl.writeLock().lock();
            
            //再次检测状态，因为其他线程有可能获得
            //写锁并且在我们操作之前改变了状态
            if(!cacheValid) {
                //data=....;
                cacheValid=true;
            }
            //在释放写锁之前通过获得读锁进行降级
            rwl.readLock().lock();
            rwl.writeLock().unlock();//释放写锁仍然拥有读锁
        }
        use(data);
        rwl.readLock().unlock();
    }
}

 

利用ReentrantReadWriteLock提供集合的并发性能：

class RWDictionary {
        private final Map<String,Data> m=new TreeMap<String,Data>();
        private final ReentrantReadWriteLock rwl=new ReentrantReadWriteLock();
        private final Lock r=rwl.readLock();
        private final Lock w=rwl.writeLock();
        
        public Data get(String key) {
            r.lock();
            try {
                return m.get(key);
            }finally {
                r.unlock();
            }
        }
        
        public String[] allKeys() {
            r.lock();
            try {
                return (String[])m.keySet().toArray();
            }finally {
                r.unlock();
            }
        }
        
        public Data put(String key,Data value) {
            w.lock();
            try {
                return m.put(key, value);
            }finally {
                w.unlock();
            }
        }
        
        public void clear() {
            w.lock();
            try {
                m.clear();
            }finally {
                w.unlock();
            }
        }
    }