ReentrantReadWriteLock

public interface ReadWriteLock

ReadWriteLock 维护了一对相关的锁，一个用于只读操作，另一个用于写入操作。只要没有 writer，读取锁可以由多个 reader 线程同时保持。写入锁是独占的。

所有 ReadWriteLock 实现都必须保证 writeLock 操作的内存同步效果也要保持与相关 readLock 的联系。也就是说，成功获取读锁的线程会看到写入锁之前版本所做的所有更新。

与互斥锁相比，读-写锁允许对共享数据进行更高级别的并发访问。虽然一次只有一个线程（writer 线程）可以修改共享数据，但在许多情况下，任何数量的线程可以同时读取共享数据（reader 线程），读-写锁利用了这一点。从理论上讲，与互斥锁相比，使用读-写锁所允许的并发性增强将带来更大的性能提高。在实践中，只有在多处理器上并且只在访问模式适用于共享数据时，才能完全实现并发性增强。

与互斥锁相比，使用读-写锁能否提升性能则取决于读写操作期间读取数据相对于修改数据的频率，以及数据的争用——即在同一时间试图对该数据执行读取或写入操作的线程数。

---

public class ReentrantReadWriteLock        implements ReadWriteLock, java.io.Serializable

支持与 ReentrantLock 类似语义的 ReadWriteLock 实现。
此类具有以下属性：

• 获取顺序
  1.非公平模式（默认）
  当非公平地（默认）构造时，未指定进入读写锁的顺序，受到 reentrancy 约束的限制。连续竞争的非公平锁可能无限期地推迟一个或多个 reader 或 writer 线程，但吞吐量通常要高于公平锁。
  2.公平模式
  当公平地构造线程时，线程利用一个近似到达顺序的策略来争夺进入。当释放当前保持的锁时，可以为等待时间最长的单个writer 线程分配写入锁，如果有一组等待时间大于所有正在等待的writer线程的reader线程，将为该组分配写入锁。
• 重入
  此锁允许reader和writer按照 ReentrantLock 的样式重新获取读取锁或写入锁。在写入线程保持的所有写入锁都已经释放后，才允许重入 reader 使用它们。
• 锁降级
  重入还允许从写入锁降级为读取锁，其实现方式是：先获取写入锁，然后获取读取锁，最后释放写入锁。但是，从读取锁升级到写入锁是不可能的。
• 锁获取的中断
  读取锁和写入锁都支持锁获取期间的中断。
• Condition 支持
  写入锁提供了一个 Condition 实现，对于写入锁来说，该实现的行为与 ReentrantLock.newCondition()提供的Condition 实现对ReentrantLock 所做的行为相同。当然，此Condition只能用于写入锁。读取锁不支持Condition，readLock().newCondition()会抛出异常。

---

示例：

package com.zero.test;import java.util.HashMap;import java.util.Map;import java.util.concurrent.locks.Lock;import java.util.concurrent.locks.ReadWriteLock;import java.util.concurrent.locks.ReentrantReadWriteLock;public class ReentrantReadWriteLockTest {    public static void main(String[] args) {//      ReadWriteMap map = new ReadWriteMap(new HashMap<String, String>());    }}/** * ReadWriteMap * <p/> * Wrapping a Map with a read-write lock * * @author Brian Goetz and Tim Peierls */class ReadWriteMap<K, V> {    private final Map<K, V> map;    private final ReadWriteLock lock = new ReentrantReadWriteLock();    private final Lock r = lock.readLock();    private final Lock w = lock.writeLock();    public ReadWriteMap(Map<K, V> map) {        this.map = map;    }    public V put(K key, V value) {        w.lock();        try {            return map.put(key, value);        } finally {            w.unlock();        }    }    public V remove(Object key) {        w.lock();        try {            return map.remove(key);        } finally {            w.unlock();        }    }    public void putAll(Map<? extends K, ? extends V> m) {        w.lock();        try {            map.putAll(m);        } finally {            w.unlock();        }    }    public void clear() {        w.lock();        try {            map.clear();        } finally {            w.unlock();        }    }    public V get(Object key) {        r.lock();        try {            return map.get(key);        } finally {            r.unlock();        }    }    public int size() {        r.lock();        try {            return map.size();        } finally {            r.unlock();        }    }    public boolean isEmpty() {        r.lock();        try {            return map.isEmpty();        } finally {            r.unlock();        }    }    public boolean containsKey(Object key) {        r.lock();        try {            return map.containsKey(key);        } finally {            r.unlock();        }    }    public boolean containsValue(Object value) {        r.lock();        try {            return map.containsValue(value);        } finally {            r.unlock();        }    }}