JUC：8读写锁：ReadWriteLock、读锁和写锁、共享锁和不加锁的区别

什么是读写锁ReadWriteLock

ReadWriteLock是java.util.concurrent.locks 包下的三个接口之一：

• 1.Condition
• 2.Lock
• 3.ReadWriteLock

官方文档是这样描述的：
ReadWriteLock维护一对关联的locks ，一个用于只读操作，一个用于写入。 read lock可以由多个阅读器线程同时进行，只要没有作者。 write lock是独家的。
所有ReadWriteLock实现必须保证的存储器同步效应writeLock操作（如在指定Lock接口）也保持相对于所述相关联的readLock 。 也就是说，一个线程成功获取读锁定将会看到在之前发布的写锁定所做的所有更新。

读写锁允许访问共享数据时的并发性高于互斥锁所允许的并发性。 它利用了这样一个事实：一次只有一个线程（ 写入线程）可以修改共享数据，在许多情况下，任何数量的线程都可以同时读取数据（因此读取器线程）。 从理论上讲，通过使用读写锁允许的并发性增加将导致性能改进超过使用互斥锁。 实际上，并发性的增加只能在多处理器上完全实现，然后只有在共享数据的访问模式是合适的时才可以。

读写锁是否会提高使用互斥锁的性能取决于数据被读取的频率与被修改的频率相比，读取和写入操作的持续时间以及数据的争用 - 即是，将尝试同时读取或写入数据的线程数。 例如，最初填充数据的集合，然后经常被修改的频繁搜索（例如某种目录）是使用读写锁的理想候选。 然而，如果更新变得频繁，那么数据的大部分时间将被专门锁定，并且并发性增加很少。 此外，如果读取操作太短，则读写锁定实现（其本身比互斥锁更复杂）的开销可以支配执行成本，特别是因为许多读写锁定实现仍将序列化所有线程通过小部分代码。 最终，只有剖析和测量将确定使用读写锁是否适合您的应用程序。

虽然读写锁的基本操作是直接的，但是执行必须做出许多策略决策，这可能会影响给定应用程序中读写锁定的有效性。 这些政策的例子包括：

在写入器释放写入锁定时，确定在读取器和写入器都在等待时是否授予读取锁定或写入锁定。 作家偏好是常见的，因为写作预计会很短，很少见。 读者喜好不常见，因为如果读者经常和长期的预期，写作可能导致漫长的延迟。 公平的或“按顺序”的实现也是可能的。
确定在读卡器处于活动状态并且写入器正在等待时请求读取锁定的读取器是否被授予读取锁定。 读者的偏好可以无限期地拖延作者，而对作者的偏好可以减少并发的潜力。
确定锁是否可重入：一个具有写锁的线程是否可以重新获取？ 持有写锁可以获取读锁吗？ 读锁本身是否可重入？
写入锁可以降级到读锁，而不允许插入写者？ 读锁可以升级到写锁，优先于其他等待读者或作者吗？

简而言之： 读可以被多线程同时读，写的时候只能有一个线程去写

使用场景和注意事项

自定义缓存，写入和读取
写入：同时只有一个线程可以写入
读取：所有线程都可以读取，读取加锁，是防止读的时候有写入操作，读加锁，并不单纯为了防止幻读，而是防止数据丢失(未读到已经提交的数据)

读锁和写锁

读锁和写锁是互斥的，锁的目标资源是不允许再写的时候读，或读的时候写。
不同的是，写锁是排它锁(独占锁)，读锁是共享锁。

• ReadWriteLock：读写锁，比如自定义缓存
• 读读共享，读写互斥，写写互斥
• 读锁：共享锁，多个线程可以同时占有
• 写锁：独占锁，也叫排它锁，一次只能被一个线程占有

共享锁和不加锁的区别?

面试问题： 共享锁和不加锁的区别?

• 读写锁是读写和写写间互斥，读读间不冲突，少写多读的场景用读写锁比较好。
• 如果你能确定数据是只读的，那不加锁也行。

代码

package juc.Test3;

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

/**
 * 读写锁，比如自定义缓存
 */
public class ReadWriteLockDemo {

    public static void main(String[] args) {

        MyCache<String> myCache = new MyCache<>();
        //5个写入
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.put(temp + "", temp + "");
            }, "线程" + i).start();
        }
        //5个读取
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCache.get(temp + "");
            }, "线程" + i).start();
        }

        /**
         * 结果输出：
         * 线程2===>执行写入。key[2].
         * 线程0===>执行写入。key[0].
         * 线程4===>执行写入。key[4].
         * 线程4===>执行写入完成。key[4].
         * 线程3===>执行写入。key[3].
         * 线程3===>执行写入完成。key[3].
         * 线程0===>执行读取。key[0].
         * 线程1===>执行读取。key[1].
         * 线程1===>执行写入。key[1].
         * 线程1===>执行读取完成。key[1].
         * 线程0===>执行读取完成。key[0].
         * 线程0===>执行写入完成。key[0].
         * 线程2===>执行写入完成。key[2].
         * 线程1===>执行写入完成。key[1].
         * 线程3===>执行读取。key[3].
         * 线程3===>执行读取完成。key[3].
         * 线程2===>执行读取。key[2].
         * 线程2===>执行读取完成。key[2].
         * 线程4===>执行读取。key[4].
         * 线程4===>执行读取完成。key[4].
         */


        MyCacheLock<String> myCacheLock = new MyCacheLock<>();
        //5个写入
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCacheLock.put(temp + "", temp + "");
            }, "线程" + i).start();
        }
        //5个读取
        for (int i = 0; i < 5; i++) {
            final int temp = i;
            new Thread(() -> {
                myCacheLock.get(temp + "");
            }, "线程" + i).start();
        }

        /**
         * 结果输出：
         * 线程0===>执行写入。key[0].
         * 线程0===>执行写入完成。key[0].
         * 线程1===>执行写入。key[1].
         * 线程1===>执行写入完成。key[1].
         * 线程2===>执行写入。key[2].
         * 线程2===>执行写入完成。key[2].
         * 线程4===>执行写入。key[4].
         * 线程4===>执行写入完成。key[4].
         * 线程3===>执行写入。key[3].
         * 线程3===>执行写入完成。key[3].
         * 线程1===>执行读取。key[1].
         * 线程1===>执行读取完成。key[1].
         * 线程2===>执行读取。key[2].
         * 线程3===>执行读取。key[3].
         * 线程4===>执行读取。key[4].
         * 线程0===>执行读取。key[0].
         * 线程4===>执行读取完成。key[4].
         * 线程3===>执行读取完成。key[3].
         * 线程2===>执行读取完成。key[2].
         * 线程0===>执行读取完成。key[0].
         */
    }
}

/*自定义缓存，写入和读取*/
class MyCache<T> {

    private volatile Map<String, T> cache = new HashMap<>();//volatile修饰：1.防止指令重排序2.保证多线程之间的可见性

    //写入
    public void put(String key, T value) {

        /*多线程情况下，一定要输出进入的线程，来判断是否符合你的预期*/
        System.out.println(Thread.currentThread().getName() + "===>执行写入。key[" + key + "].");
        cache.put(key, value);
        System.out.println(Thread.currentThread().getName() + "===>执行写入完成。key[" + key + "].");
    }

    //读取
    public T get(String key) {

        /*多线程情况下，一定要输出进入的线程，来判断是否符合你的预期*/
        System.out.println(Thread.currentThread().getName() + "===>执行读取。key[" + key + "].");
        T t = cache.get(key);
        System.out.println(Thread.currentThread().getName() + "===>执行读取完成。key[" + key + "].");
        return t;
    }
}

/*自定义缓存，写入和读取*/
class MyCacheLock<T> {

    private volatile Map<String, T> cache = new HashMap<>();//volatile修饰：1.防止指令重排序2.保证多线程之间的可见性
    //读写锁：更加细粒度的控制，读读共享，读写互斥，写写互斥
    private ReadWriteLock lock = new ReentrantReadWriteLock();

    //写入：同时只有一个线程可以写入
    public void put(String key, T value) {

        lock.writeLock().lock();//加写锁
        try {
            /*多线程情况下，一定要输出进入的线程，来判断是否符合你的预期*/
            System.out.println(Thread.currentThread().getName() + "===>执行写入。key[" + key + "].");
            cache.put(key, value);
            System.out.println(Thread.currentThread().getName() + "===>执行写入完成。key[" + key + "].");
        } finally {
            lock.writeLock().unlock();//释放写锁
        }
    }

    //读取：所有线程都可以读取，读取加锁，是防止读的时候有写入操作，读加锁，并不单纯为了防止幻读，而是防止数据丢失(未读到已经提交的数据)
    public T get(String key) {

        lock.readLock().lock();
        try {
            /*多线程情况下，一定要输出进入的线程，来判断是否符合你的预期*/
            System.out.println(Thread.currentThread().getName() + "===>执行读取。key[" + key + "].");
            T t = cache.get(key);
            System.out.println(Thread.currentThread().getName() + "===>执行读取完成。key[" + key + "].");
            return t;
        } finally {
            lock.readLock().unlock();
        }
    }
}