JUC理解（5）

读写锁ReadWriteLock

我们经常会做种操作，在我们对数据进行读的时候，希望大家都能读，而我们对数据进行写的时候，我们希望只能有一个人写。这就是读写锁。

介绍

ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的。

所有ReadWriteLock实现必须保证的存储器同步效应writeLock操作（如在指定Lock接口）也保持相对于所述相关联的readLock 。 也就是说，一个线程成功获取读锁定将会看到在之前发布的写锁定所做的所有更新。

他本身是一个接口，只有一个具体实现ReentrantReadWriteLock。

ReentrantReadWriteLock

在这个实现类中，有两个内部类分别是WriteLock和ReadLock。通过这两个锁实现了读写的操作。
两个类因为实现了Lock接口，所以在方法是的使用基本同我之前博客的所讲。不同的是，他们多了个重要的属性来完成读写锁的功能。

private final Sync sync;

这个Sync也是ReentrantReadWriteLock的一个同步实现，分为公平和不公平版本。Sync也继承了一个AbstractQueuedSynchronizer的抽象类，我们可以在WriteLock加锁方法里面看见一个属性的方法acquire，这个方法就像Semaphore的acquire方法一样，同样在ReadLock加锁方法acquireShared方法，从字面意思我们就知道这个是共享的，也就是说读是共享锁的，而写是独占锁的。

下面我用一个缓存的示例

/**
 * @author wei
 * @Date: 2020/12/23
 * ReadWriteLock
 */
public class ReadWriteLockDemo {
    public static void main(String[] args) {
        MyCacheLock myCache = new MyCacheLock();

        for (int i = 0;i < 5;i++){
            final int temp = i;
            new Thread(()->{
                myCache.put(temp+"",temp+"");
            },String.valueOf(i)).start();
        }

        for (int i = 0;i < 5;i++){
            final int temp = i;
            new Thread(()->{
                myCache.get(temp+"");
            },String.valueOf(i)).start();
        }
    }
}


/**
 * 加锁的
 */
class MyCacheLock{

    private volatile Map<String,Object> map = new HashMap<>();
    // 读写锁 ：更加细粒度的控制
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    /**
     * 存 写  写入的时候只希望同时只有一个线程
     */
    public void put(String key,Object value){
        lock.writeLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"写入"+key);
            map.put(key,value);
            System.out.println(Thread.currentThread().getName()+"写入OK");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.writeLock().unlock();
        }
    }

    /**
     * 读 取  所有人都可以读
     * @return
     */
    public void get(String key){
        lock.readLock().lock();
        try{
            System.out.println(Thread.currentThread().getName()+"读取"+key);
            Object o = map.get(key);
            System.out.println(Thread.currentThread().getName()+"读取完成");
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            lock.readLock().unlock();
        }

    }

}

/**
 * 自定义缓存
 */
class MyCache{

    private volatile Map<String,Object> map = new HashMap<>();


    /**
     * 存 写
     */
    public void put(String key,Object value){
        System.out.println(Thread.currentThread().getName()+"写入"+key);
        map.put(key,value);
        System.out.println(Thread.currentThread().getName()+"写入OK");
    }

    /**
     * 读 取
     * @return
     */
    public void get(String key){
        System.out.println(Thread.currentThread().getName()+"读取"+key);
        Object o = map.get(key);
        System.out.println(Thread.currentThread().getName()+"读取完成");
    }

}

输出：

我们可以发现，这些都是成对出现的，无论你怎么运行，他都是成对，而不是分开的。