特点：读的时候可以让多个线程读，写的时候只能让一个线程写。

    1. import java.util.HashMap;
    2. import java.util.Map;
    3. import java.util.concurrent.locks.Lock;
    4. import java.util.concurrent.locks.ReadWriteLock;
    5. import java.util.concurrent.locks.ReentrantLock;
    6. import java.util.concurrent.locks.ReentrantReadWriteLock;
    8. /**
    9.  * 独占锁（写锁） 一次只能被一个线程占有
    10.  * 共享锁（读锁） 多个线程可以同时占有
    11.  * ReadWriteLock
    12.  * 读-读  可以共存！
    13.  * 读-写  不能共存！
    14.  * 写-写  不能共存！
    15.  */
    16. public class ReadWriteLockDemo {
    17.     public static void main(String[] args) {
    18.         MyCache myCache = new MyCache();
    20.         // 写入
    21.         for (int i = 1; i <= 5 ; i++) {
    22.             final int temp = i;
    23.             new Thread(()->{
    24.                 myCache.put(temp+"",temp+"");
    25.             },String.valueOf(i)).start();
    26.         }
    28.         // 读取
    29.         for (int i = 1; i <= 5 ; i++) {
    30.             final int temp = i;
    31.             new Thread(()->{
    32.                 myCache.get(temp+"");
    33.             },String.valueOf(i)).start();
    34.         }
    36.     }
    37. }
    39. // 加锁的
    40. class MyCacheLock{
    42.     private volatile Map<String,Object> map = new HashMap<>();
    43.     // 读写锁： 更加细粒度的控制
    44.     private ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    45.     private Lock lock = new ReentrantLock();
    47.     // 存，写入的时候，只希望同时只有一个线程写
    48.     public void put(String key,Object value){
    49.         readWriteLock.writeLock().lock();
    50.         try {
    51.             System.out.println(Thread.currentThread().getName()+"写入"+key);
    52.             map.put(key,value);
    53.             System.out.println(Thread.currentThread().getName()+"写入OK");
    54.         } catch (Exception e) {
    55.             e.printStackTrace();
    56.         } finally {
    57.             readWriteLock.writeLock().unlock();
    58.         }
    59.     }
    61.     // 取，读，所有人都可以读！
    62.     public void get(String key){
    63.         readWriteLock.readLock().lock();
    64.         try {
    65.             System.out.println(Thread.currentThread().getName()+"读取"+key);
    66.             Object o = map.get(key);
    67.             System.out.println(Thread.currentThread().getName()+"读取OK");
    68.         } catch (Exception e) {
    69.             e.printStackTrace();
    70.         } finally {
    71.             readWriteLock.readLock().unlock();
    72.         }
    73.     }
    75. }
    77. /**
    78.  * 自定义缓存
    79.  */
    80. class MyCache{
    82.     private volatile Map<String,Object> map = new HashMap<>();
    84.     // 存，写
    85.     public void put(String key,Object value){
    86.         System.out.println(Thread.currentThread().getName()+"写入"+key);
    87.         map.put(key,value);
    88.         System.out.println(Thread.currentThread().getName()+"写入OK");
    89.     }
    91.     // 取，读
    92.     public void get(String key){
    93.         System.out.println(Thread.currentThread().getName()+"读取"+key);
    94.         Object o = map.get(key);
    95.         System.out.println(Thread.currentThread().getName()+"读取OK");
    96.     }
    98. }