Java读写锁

Java读写锁，ReadWriteLock.java接口， RentrantReadWriteLock.java实现。通过读写锁，可以实现读-读线程并发，读-写，写-读线程互斥进行。以前面试遇到一个问题，ConcurrentHashMap的实现原理，如何封装Map效率更高。今天看了《Java并发编程实战》，封装的ReadWriteMap类，效率就比ConcurrentHashMap效率更高，在读多写少的场景。

ReadWriteMap.java

 public class ReadWriteMap<K, V> {
     private final Map<K, V> map;
     private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
     private final Lock readLock = readWriteLock.readLock();
     private final Lock writeLock = readWriteLock.writeLock();
 
     public ReadWriteMap(Map<K, V> map){
         this.map = map;
     }
 
     public V put(K key, V value){
         writeLock.lock();
         try{
             return map.put(key, value);
         } finally {
             //释放锁，一定要写在finally里面
             writeLock.unlock();
         }
     }
 
     public V get(K key){
         readLock.lock();
         try{
             return map.get(key);
         } finally {
             readLock.unlock();
         }
     }
 
 }

ConcurrentHashMap里面的putVal()方法

  /** Implementation for put and putIfAbsent */
     final V putVal(K key, V value, boolean onlyIfAbsent) {
         if (key == null || value == null) throw new NullPointerException();
         int hash = spread(key.hashCode());
         int binCount = 0;
         for (Node<K,V>[] tab = table;;) {
             Node<K,V> f; int n, i, fh;
             if (tab == null || (n = tab.length) == 0)
                 tab = initTable();
             else if ((f = tabAt(tab, i = (n - 1) & hash)) == null) {
                 if (casTabAt(tab, i, null,
                              new Node<K,V>(hash, key, value, null)))
                     break;                   // no lock when adding to empty bin
             }
             else if ((fh = f.hash) == MOVED)
                 tab = helpTransfer(tab, f);
             else {
                 V oldVal = null;
                 synchronized (f) {
                     if (tabAt(tab, i) == f) {
                         if (fh >= 0) {
                             binCount = 1;
                             for (Node<K,V> e = f;; ++binCount) {
                                 K ek;
                                 if (e.hash == hash &&
                                     ((ek = e.key) == key ||
                                      (ek != null && key.equals(ek)))) {
                                     oldVal = e.val;
                                     if (!onlyIfAbsent)
                                         e.val = value;
                                     break;
                                 }
                                 Node<K,V> pred = e;
                                 if ((e = e.next) == null) {
                                     pred.next = new Node<K,V>(hash, key,
                                                               value, null);
                                     break;
                                 }
                             }
                         }
                         else if (f instanceof TreeBin) {
                             Node<K,V> p;
                             binCount = 2;
                             if ((p = ((TreeBin<K,V>)f).putTreeVal(hash, key,
                                                            value)) != null) {
                                 oldVal = p.val;
                                 if (!onlyIfAbsent)
                                     p.val = value;
                             }
                         }
                     }
                 }
                 if (binCount != 0) {
                     if (binCount >= TREEIFY_THRESHOLD)
                         treeifyBin(tab, i);
                     if (oldVal != null)
                         return oldVal;
                     break;
                 }
             }
         }
         addCount(1L, binCount);
         return null;
     }

使用的是synchronized进行同步，synchronized是独占锁，在读多写少的情况下效率不高，极端情况就是所有都是读线程，串行执行。