十五、ReadWriteLock读写锁

1. 读写锁。

   串行写入，并行读取。

2. 示例

   public class ReadWriteLockTest {
       public static void main(String[] args) {
           MyCacheLock myCacheLock = new MyCacheLock();
   
           //5条线程写
           for (int i = 1; i <= 5; i++) {
               final int tp = i;
               new Thread(()->{
                   myCacheLock.setCache(tp+"",tp+"");
               },String.valueOf(i)).start();
           }
   
           //5条线程读
           for (int i = 1; i <= 5; i++) {
               final int tp = i;
               new Thread(()->{
                   myCacheLock.getCache(tp+"");
               },String.valueOf(i)).start();
           }
       }
   }
   
   /**
    * 缓存类
    */
   class MyCacheLock{
   
       //volatile 保证可见性
       private volatile Map<String,Object> map = new HashMap<>();
       private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
   
       /**
        * 写入缓存
        * @param key
        * @param val
        */
       public void setCache(String key,Object val){
           readWriteLock.writeLock().lock();
           try{
               System.out.println("线程"+Thread.currentThread().getName()+"开始写入：" + key);
               map.put(key,val);
               System.out.println("线程"+Thread.currentThread().getName()+"写入：" + key + "完成");
           }
           finally {
               readWriteLock.writeLock().unlock();
           }
       }
   
       /**
        * 读取缓存
        * @param key
        * @return
        */
       public Object getCache(String key){
           readWriteLock.readLock().lock();
           try{
               System.out.println("线程"+Thread.currentThread().getName()+"开始读取：" + key);
               Object res = map.get(key);
               System.out.println("线程"+Thread.currentThread().getName()+"读取：" + key + "完成");
               return res;
           }
           finally {
               readWriteLock.readLock().unlock();
           }
       }
   }
   

   打印结果

   线程1开始写入：1
   线程1写入：1完成
   线程2开始写入：2
   线程2写入：2完成
   线程3开始写入：3
   线程3写入：3完成
   线程4开始写入：4
   线程4写入：4完成
   线程5开始写入：5
   线程5写入：5完成
   线程3开始读取：3
   线程3读取：3完成
   线程4开始读取：4
   线程1开始读取：1
   线程1读取：1完成
   线程2开始读取：2
   线程2读取：2完成
   线程5开始读取：5
   线程4读取：4完成
   线程5读取：5完成
   

   从上面结果可以看出，写入线程在写操作时，从写入开始到写入完成，中间是不会插入其他内容的。因为写锁是独占的，具有排他性。此时其他的写线程和所有读线程都会等待。

   读取线程在开始读取和读取完成之间插入有其他内容。是因为读锁是共享的，其他读线程可以共同进入，而写线程需要等待。