JUC---ReentrantReadWriteLock读写锁

读锁-共享锁：比如一行数据可以被多个线程加锁，可以给很多人去读
写锁-独占锁：只能一个线程支持上锁，比如一个线程对id=2上完的锁后 又对id=1进行update，但是另外个线程对id=1这行数据上了一个写锁，所以此时对id=2上写锁的线程需要灯另外对id=1这行数据上的锁解开后才能解开，所以就造成了死锁；
解决方法就是说话算话，上写锁就只做写操作，读锁也是；
我们自己生产环境安装的mysql死锁检测机制默认打开，如果检测到死锁会自动解开
实际环境不开，因为伤性能

范围锁-间隙锁：比如对id<5 id >2; 这样这个范围内如果有线程要插入数据就会不成功，所以这个间隙锁的使用需要注意

class MyCache{
    //volatile 虽然丢失了原子性，但是实现了可见行，被volatile修饰的变量能够保证每个线程能够获取该变量的最新值，从而避免出现数据脏读的现象。
    private volatile Map<String,String> map=new HashMap<>();
    //读写锁
    private ReadWriteLock rwLock = new ReentrantReadWriteLock();

    public void put(String key,String value){
        rwLock.writeLock().lock();
        System.out.println(Thread.currentThread().getName()+"\t 准备写入数据");
        try {
            TimeUnit.MILLISECONDS.sleep(200);
            map.put(key, value);
            System.out.println(Thread.currentThread().getName()+"\t写入数据成功");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }




    }
    public void get(String key){
        rwLock.readLock().lock();
        System.out.println(Thread.currentThread().getName()+"\t 准备读取数据");
        try {
            TimeUnit.MILLISECONDS.sleep(200);
            System.out.println("读取value："+map.get(key));
            System.out.println(Thread.currentThread().getName()+"\t读取数据成功");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally {
            rwLock.readLock().unlock();
        }

    }
}

public class ReadWriteLockDemo {
    public static void main(String[] args) throws InterruptedException {
        MyCache myCache = new MyCache();
        for (int i = 1; i <= 5; i++) {
            String key=String.valueOf(i);
            new Thread(()->{
                myCache.put(key, UUID.randomUUID().toString().substring(0,8));
            },String.valueOf(i)).start();
        }

        TimeUnit.SECONDS.sleep(2);

        for (int i = 1; i <= 5; i++) {
            String key=String.valueOf(i);
            new Thread(()->{
                myCache.get(key);
            },String.valueOf(i)).start();
        }


    }
}

上面的例子将读写分离：
在写方法中：使用writeLock获取一把写锁，然后内部List写入数据，最后在finally中释放写锁。

在读方法中：使用readLock获取一把读锁，然后内部List读取数据，最后再finally中释放读锁。

ReentrantReadWriteLock：锁升级

升级的意思就是，读锁在获取写锁之前，一定要先释放读锁
简单来说就是在一个需求需要读和写的方法里，读先获取读锁，在写操作之前就需要将读锁释放，在进行写锁

public void readAndWrite(){
        //读数据
        rwLock.readLock().lock();
        String s = map.get("6");
        if (s==null){
            System.out.println("写数据；（写之前释放读锁）");
            rwLock.readLock().unlock();
            rwLock.writeLock().lock();
            map.put("6","测试写入数据");
            //释放写锁
            rwLock.writeLock().unlock();
            //读锁上锁
            rwLock.readLock().lock();
        }
        System.out.println("map(6)数据是："+map.get("6"));
        rwLock.readLock().unlock();


    }