Java并发 -- ReadWriteLock

读多写少

理论上，利用管程和信号量可以解决所有并发问题，但JUC提供了很多工具类，_细分场景优化性能，提升易用性_
针对读多写少的并发场景，JUC提供了读写锁，即ReadWriteLock

读写锁

读写锁是一种广泛使用的通用技术，并非Java所特有
所有读写锁都遵守3条基本原则
- 允许多个线程同时读共享变量 – 与互斥锁的重要区别
- 只允许一个线程写共享变量
- 如果一个写线程正常执行写操作，此时禁止读线程读取共享变量

缓存

public class Cache<K, V> {
    private final Map<K, V> map = new HashMap<>();
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    // 读锁
    private final Lock readLock = readWriteLock.readLock();
    // 写锁
    private final Lock writeLock = readWriteLock.writeLock();

    // 读缓存 -- 懒加载
    public V get(K key) {
        V v = null;
        // 读缓存
        readLock.lock(); // 1
        try {
            v = map.get(key); // 2
        } finally {
            readLock.unlock(); // 3
        }
        // 缓存中存在，直接返回
        if (v != null) { // 4
            return v;
        }
        // 缓存中不存在，查询数据库
        writeLock.lock(); // 5
        try {
            // 再次验证，其他线程可能已经查询过数据库了
            // 避免在高并发场景下重复查询数据库的问题
            v = map.get(key); // 6
            if (v == null) { // 7
                // 查询数据库
                v = loadFromDb(key);
                map.put(key, v);
            }
        } finally {
            writeLock.unlock();
        }
        return v;
    }

    private V loadFromDb(K key) {
        return null;
    }

    // 写缓存
    public V put(K key, V value) {
        writeLock.lock();
        try {
            return map.put(key, value);
        } finally {
            writeLock.unlock();
        }
    }
}

锁升级

ReadWriteLock不支持锁升级（读锁升级为写锁），readLock还没有释放，因此无法获取writeLock，这会导致_线程阻塞_

readLock.lock();
try {
    V v = map.get(key);
    if (v == null) {
        writeLock.lock();
        try {
            map.put(key, loadFromDb(key));
        } finally {
            writeLock.unlock();
        }
    }
} finally {
    readLock.unlock();
}

锁降级

readLock.lock();
if (!cacheValid) {
    // 因为不允许读锁升级为写锁，先释放读锁
    readLock.unlock();
    writeLock.lock();
    try {
        if (!cacheValid) {
            cacheValid = true;
        }
        // 释放写锁前，允许降级为读锁！！
        readLock.lock(); // 1
    } finally {
        writeLock.unlock();
    }
}

// 此时仍然持有读锁
try {
    // 使用数据
} finally {
    readLock.unlock();
}