存在的原因

锁的排他性, 让线程不能同时得到锁, 但是

synchronized，ReentrantLock，无论是读还是写，它们都要求获得相同的锁(排他性)。
在一些场景中，这是没有必要的，多个线程的读操作完全可以并行，在读多写少的场景中，让读操作并行可以明显提高性能。

适用

读多写少, 读的时间长

不然一般不用, 开销大

定义

就是通过一个ReadWriteLock产生两个锁，
一个读锁，一个写锁。只有"读-读"操作是可以并行的.

ReadWriteLock

public interface ReadWriteLock {
    Lock readLock();
    Lock writeLock();
}

这个接口是读写锁的抽象,
里面有 readLock() writeLock() 这2方法, 得到读锁写锁,

返回的锁是Lock类型的(这是锁接口,ReentrantLock也实现它)

使用例子:

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class ReadWriteLockUsage {
  private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
  private final Lock readLock = rwLock.readLock();
  private final Lock writeLock = rwLock.writeLock();

  // 读线程执行该方法
  public void reader() {
    readLock.lock(); // 申请读锁
    try {
      // 在此区域读取共享变量
    } finally {
      readLock.unlock();// 总是在finally块中释放锁，以免锁泄漏
    }
  }

  // 写线程执行该方法
  public void writer() {
    writeLock.lock(); // 申请读锁
    try {
      // 在此区域访问（读、写）共享变量
    } finally {
      writeLock.unlock();// 总是在finally块中释放锁，以免锁泄漏
    }
  }
}

ReentrantReadWriteLock是ReadWriteLock的默认实现
从ReadWriteLock 可得到的类型是 Lock, 看起来就是普通的锁, 是不是实现了读写锁的功能, 看实现者的良心
读写锁都是普通Lock, 没啥特别的,和ReentrantLock 一样用就行了

锁的降级Downgrade

就是有在得写锁的时候, 可继续得读锁,
写锁锁住, 不释放, 在其临界区内得读锁

这样严格排他的写锁,就可以降级为可共享的读锁了

ReentrantReadWriteLock这个读写锁的默认实现, 是个可重入锁

例子:

    writeLock.lock(); // 申请写锁
    try {
      // 对共享数据进行更新
      // ...
      // 当前线程在持有写锁的情况下申请读锁readLock
      readLock.lock();
    } finally {
      writeLock.unlock();// 释放写锁
    }

为什么只能降级不能升级:

内部实现先得读锁再得写锁会死锁

为什么要这么设计?
比如同一段代码写着
先 readLock.lock();
再writeLock.unlock();
t1,t2,t3 线程都先拿到了读锁, t1去拿写锁要等t2 t3先释放读锁, 他们也在等t1 就死锁了

使用例子: 实现一个缓存类MyCache

public class MyCache {

    //数据存这
    private Map<String, Object> map = new HashMap<>();
    
    private ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private Lock readLock = readWriteLock.readLock();
    private Lock writeLock = readWriteLock.writeLock();

    //读要得读锁
    public Object get(String key) {
        readLock.lock();
        try {
            return map.get(key);
        } finally {
            readLock.unlock();
        }
    }

    //写要写锁
    public Object put(String key, Object value) {
        writeLock.lock();
        try {
            return map.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }

    public void clear() {
        writeLock.lock();
        try {
            map.clear();
        } finally {
            writeLock.unlock();
        }
    }

}