独占锁：指该锁一次只能被一个线程所持有。对 ReentrantLock 和 Synchronized 而言都是独占锁
共享锁：指该锁可被多个线程所持有。
ReentrantReadWriteLock其读锁是共享锁，其写锁是独占锁。读锁的共享锁可保证并发读是非常高效的，读写，写读，写写的过程是互斥。

通俗理解：机场大屏幕，每个人都能看到，这就是读共享；但是在在机场通知旅客飞机延误的只能是一个人，如果一群广播员播放，将会乱套，这就是独占写锁。同时在播报的时候，屏幕信息就不能更改，这就是互斥。 即 多个线程同时读一个资源类没有任何问题，所以为了满足并发量，读取共享资源应该可以同时进行。但是如果有一个线程想去写共享资源，就不应该再有其他线程可以对该资源进行读或写。

一、代码展示

正面例子

共享缓存

  1. public class MyCache {
  2.     /**
  3.      * volatile关键字可以查看前面的包
  4.      * 管缓存的，必须用volatile，保证可见性和禁止指令重排，一个线程对其进行了修改，必须让其它线程知道
  5.      */
  6.     private volatile Map<String, Object> map = new HashMap<>();
  8.     /**
  9.      * 可以对比加了读写锁和没加读写锁的区别
  10.      */
  11.     private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
  13.     /**
  14.      * 写操作：原子+独占，整个写过程必须完整的统一体，不能被分割和打断
  15.      *
  16.      * @param key
  17.      * @param value
  18.      */
  19.     public void put(String key, Object value) {
  20.         readWriteLock.writeLock().lock();
  21.         try {
  22.             System.out.println(Thread.currentThread().getName() + " 正在写入:" + "key:" + key + ",value:" + value);
  23.             // 暂定一会模拟网络延迟
  24.             try {
  25.                 TimeUnit.MILLISECONDS.sleep(300);
  26.             } catch (InterruptedException e) {
  27.                 e.printStackTrace();
  28.             }
  29.             map.put(key, value);
  30.             System.out.println(Thread.currentThread().getName() + " 写入完成:" + "key:" + key + ",value:" + value);
  31.         } catch (Exception e) {
  32.             e.printStackTrace();
  33.         } finally {
  34.             readWriteLock.writeLock().unlock();
  35.         }
  36.     }
  38.     public void get(String key) {
  39.         readWriteLock.readLock().lock();
  40.         try {
  41.             System.out.println(Thread.currentThread().getName() + " 正在读取:" + "key:" + key);
  42.             // 暂定一会模拟网络延迟
  43.             try {
  44.                 TimeUnit.MILLISECONDS.sleep(300);
  45.             } catch (InterruptedException e) {
  46.                 e.printStackTrace();
  47.             }
  48.             Object result = map.get(key);
  49.             System.out.println(Thread.currentThread().getName() + " 读取完成:" + "key:" + key + ",result:" + result);
  50.         } catch (Exception e) {
  51.             e.printStackTrace();
  52.         } finally {
  53.             readWriteLock.readLock().unlock();
  54.         }
  55.     }
  57.     public void clearMap() {
  58.         map.clear();
  59.     }
  60. }

测试

  1. public class ReadWriteLockDemo {
  3.      public static void main(String[] args) {
  4.         MyCache myCache = new MyCache();
  5. //        MyCacheNoLock myCache = new MyCacheNoLock();
  6.         for (int i = 0; i < 5; i++) {
  7.             final int i1 = i;
  8.             new Thread(() -> {
  9.                 myCache.put(i1 + "", i1 + "");
  10.             }, String.valueOf(i)).start();
  12.             new Thread(() -> {
  13.                 myCache.get(i1 + "");
  14.             }, String.valueOf(i)).start();
  15.         }
  16.     }
  17. }

结果

  1. 0 正在写入:key:0,value:0
  2. 0 写入完成:key:0,value:0
  3. 0 正在读取:key:0
  4. 0 读取完成:key:0,result:0
  5. 1 正在写入:key:1,value:1
  6. 1 写入完成:key:1,value:1
  7. 1 正在读取:key:1
  8. 1 读取完成:key:1,result:1
  9. 2 正在写入:key:2,value:2
  10. 2 写入完成:key:2,value:2
  11. 2 正在读取:key:2
  12. 2 读取完成:key:2,result:2
  13. 3 正在写入:key:3,value:3
  14. 3 写入完成:key:3,value:3
  15. 3 正在读取:key:3
  16. 3 读取完成:key:3,result:3
  17. 4 正在写入:key:4,value:4
  18. 4 写入完成:key:4,value:4
  19. 4 正在读取:key:4
  20. 4 读取完成:key:4,result:4

可以很明显的看到，先写后读的，这样可以保证每次读到的数据都是最新的。展现了读写锁的，读（共享），写（独占），读写（互斥）

反面例子

以下代码没有加读写锁

  1. public class MyCacheNoLock {
  2.     /**
  3.      * volatile关键字可以查看前面的包
  4.      * 管缓存的，必须用volatile，保证可见性和禁止指令重排，一个线程对其进行了修改，必须让其它线程知道
  5.      */
  6.     private volatile Map<String, Object> map = new HashMap<>();
  8.     /**
  9.      * 写操作：原子+独占，整个写过程必须完整的统一体，不能被分割和打断
  10.      *
  11.      * @param key
  12.      * @param value
  13.      */
  14.     public void put(String key, Object value) {
  15.         System.out.println(Thread.currentThread().getName() + " 正在写入:" + "key:" + key + ",value:" + value);
  16.         // 暂定一会模拟网络延迟
  17.         try {
  18.             TimeUnit.MILLISECONDS.sleep(300);
  19.         } catch (InterruptedException e) {
  20.             e.printStackTrace();
  21.         }
  22.         map.put(key, value);
  23.         System.out.println(Thread.currentThread().getName() + " 写入完成:" + "key:" + key + ",value:" + value);
  25.     }
  27.     public void get(String key) {
  28.         System.out.println(Thread.currentThread().getName() + " 正在读取:" + "key:" + key);
  29.         // 暂定一会模拟网络延迟
  30.         try {
  31.             TimeUnit.MILLISECONDS.sleep(300);
  32.         } catch (InterruptedException e) {
  33.             e.printStackTrace();
  34.         }
  35.         Object result = map.get(key);
  36.         System.out.println(Thread.currentThread().getName() + " 读取完成:" + "key:" + key + ",result:" + result);
  37.     }
  39.     public void clearMap() {
  40.         map.clear();
  41.     }
  42. }

结果

  1. 0 正在写入:key:0,value:0
  2. 2 正在写入:key:2,value:2
  3. 1 正在写入:key:1,value:1
  4. 4 正在写入:key:4,value:4
  5. 3 正在写入:key:3,value:3
  6. 0 正在读取:key:0
  7. 1 正在读取:key:1
  8. 2 正在读取:key:2
  9. 3 正在读取:key:3
  10. 4 正在读取:key:4
  11. 3 写入完成:key:3,value:3
  12. 2 写入完成:key:2,value:2
  13. 4 写入完成:key:4,value:4
  14. 1 写入完成:key:1,value:1
  15. 0 写入完成:key:0,value:0
  16. 0 读取完成:key:0,result:null   // 没有读取到
  17. 1 读取完成:key:1,result:1
  18. 3 读取完成:key:3,result:null
  19. 2 读取完成:key:2,result:null
  20. 4 读取完成:key:4,result:4

可以看到，还没有写入完成，就开始读取了，导致一些数据没有读取到。

二、总结

  • 读-读共存
    读-写不能共存
     写-写不能共存
    写操作：原子+独占，整个写过程必须完整的统一体，不能被分割和打断
    �