读写锁：多个线程同时读共享资源，但是有线程对共享资源写，则其他线程不能读 也不能写

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁：多个线程同时读共享资源，但是有线程对共享资源写，则其他线程不能读 也不能写
 * 读读共存；读写不共存；写写不共存
 * 写：原子+独占
 */
public class ReadWriteLockDemo {
    public static void main(String[] args){
        final MyCache myCache = new MyCache();
        for (int i = 0; i < 6; i++) {
            final int tem = i;
            Thread thread =  new Thread(new Runnable() {
                @Override
                public void run() {
                    myCache.put(tem+"",tem+"");
                }
            });
            thread.setName(i+"");
            thread.start();
        }

        for (int i = 0; i < 6; i++) {
            final int tem = i;
            Thread thread =  new Thread(new Runnable() {
                @Override
                public void run() {
                    myCache.get(tem+"");
                }
            });
            thread.setName(i+"");
            thread.start();
        }
    }
}
//资源类
class MyCache{
     private volatile Map<String,Object> map = new HashMap<>();
    //private Lock lock = new ReentrantLock();
    private ReentrantReadWriteLock lock = new ReentrantReadWriteLock();

    public void put(String key,Object value){
        //写限制 必须写入完成后才可另一个线程开始
        lock.writeLock().lock();

        try {
            System.out.println(Thread.currentThread().getName()+"正在写入");
            Thread.sleep(997);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入完成");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }


    }
    public void get(String key){
        //读不限制
        lock.readLock().lock();

        try {
            System.out.println(Thread.currentThread().getName()+"正在读取");
            Thread.sleep(997);
            Object result =  map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完成" +result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.readLock().unlock();
        }


    }
}