java juc 读写锁（ReentrantReadWriteLock）

学习这个，首先了解下乐观锁和悲观锁的概念，这里参考了下面的博文
https://blog.csdn.net/qq_34337272/article/details/81072874

乐观锁与悲观锁

乐观锁

总是假设最好的情况，每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人有没有去更新这个数据，可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型，这样可以提高吞吐量，像数据库提供的类似于write_condition机制，其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。

悲观锁

总是假设最坏的情况，每次去拿数据的时候都认为别人会修改，所以每次在拿数据的时候都会上锁，这样别人想拿这个数据就会阻塞直到它拿到锁（共享资源每次只给一个线程使用，其它线程阻塞，用完后再把资源转让给其它线程）。传统的关系型数据库里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。

两种锁的使用场景

从上面对两种锁的介绍，我们知道两种锁各有优缺点，不可认为一种好于另一种，像乐观锁适用于写比较少的情况下（多读场景），即冲突真的很少发生的时候，这样可以省去了锁的开销，加大了系统的整个吞吐量。但如果是多写的情况，一般会经常产生冲突，这就会导致上层应用会不断的进行retry，这样反倒是降低了性能，所以一般多写的场景下用悲观锁就比较合适。

ReentrantReadWriteLock

例子

public class MyCacheDemo {
    private Map<String,String> map = new HashMap<>();
    private ReentrantReadWriteLock rwLock = new ReentrantReadWriteLock();
    private void put(String key,String value){
        rwLock.writeLock().lock();
        try {
            System.out.println(Thread.currentThread().getName()+"开始写入key:"+key);
            map.put(key,value);
            TimeUnit.MILLISECONDS.sleep(100);
            System.out.println(Thread.currentThread().getName()+"完成写入key:"+key);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }
    }
    private void get(String key){
        rwLock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"开始读取key:"+key);
            map.get(key);
            System.out.println(Thread.currentThread().getName()+"完成读取key:"+key);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rwLock.writeLock().unlock();
        }
    }
    public static void main(String[] args) {
        MyCacheDemo myCacheDemo = new MyCacheDemo();
        for(int i=1;i<=6;i++){
            int finalI = i;
            new Thread(()->{
                myCacheDemo.put(String.valueOf(finalI),String.valueOf(finalI));
            },String.valueOf(i)).start();
            try {
                TimeUnit.SECONDS.sleep(2);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            new Thread(()->{
                for (int j=1;j<=6;j++){
                    int finalJ = j;
                    new Thread(()->{
                        myCacheDemo.get(String.valueOf(finalJ));
                    }).start();
                }
            }).start();
        }
    }
}

原理