java ReentrantReadWriteLock 读写锁的使用

前言：在一下读多写少的业务场景中，使用读写锁可以提高程序的性能

1. 读写锁

注意点一：加了锁记得及时释放

注意点二：读读不互斥(共享锁)，读写互斥(排他锁)，写写互斥(排他锁)

• 读读不互斥(共享锁)：一个线程进来加了读锁，第二个线程还能进来读该资源

• 读写互斥(排他锁)：一个线程进来加了读锁，第二个线程进来就加不了写锁，需要等待第一个线程释放读锁

• 写写互斥(排他锁)：一个线程进来加了写锁，第二个线程进来就加不了写锁，需要等待第一个线程释放写锁

• 锁降级：第一个线程先加了写锁，接着在保持写锁的同时尝试获取读锁，如果成功获取读锁，线程释放写锁，此时线程只持有读锁

2. 案例

核心方法就是 getVal 和 getValue

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.locks.ReentrantReadWriteLock;

public class TestCache extends Thread {

    private static ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
    private static ReentrantReadWriteLock.ReadLock readLock = lock.readLock();
    private static ReentrantReadWriteLock.WriteLock writeLock = lock.writeLock();

    private static Map<String, Object> cache = new ConcurrentHashMap<>(10);

    private String key;

    public TestCache() {
    }

    public TestCache(String key) {
        this.key = key;
    }

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public static Object getVal(String key) {
        // 加读锁1
        readLock.lock();
        System.out.println("[" + key + "]线程" + Thread.currentThread().getId() + "进入读锁");
        Object o = cache.get(key);
        if (o != null) {
            // 释放读锁1
            readLock.unlock();
            return o;
        }

        // 释放读锁1, 避免下面写锁会锁死
        readLock.unlock();
        // 加写锁2
        writeLock.lock();
        try {
            System.out.println("[" + key + "]线程" + Thread.currentThread().getId() + "进入[写锁]!");
            // 这里可以做业务查询数据并写入
            o = "结果";
            cache.put(key, o);
        } finally {
            // 释放写锁2
            writeLock.unlock();
        }
        return o;
    }

    /**
     * 该方法和 getVal 方法是一样的, 只不过该方法有一个锁降级
     */
    public static Object getValue(String key) {
        // 加读锁1
        readLock.lock();
        System.out.println("[" + key + "]线程" + Thread.currentThread().getId() + "进入读锁");

        Object o = cache.get(key);
        if (o == null) {
            // 释放[读锁1], 避免下面写锁会锁死
            readLock.unlock();
            // 加写锁2
            writeLock.lock();
            try {
                System.out.println("[" + key + "]线程" + Thread.currentThread().getId() + "进入[写锁]!");
                // 这里可以做业务查询数据并写入
                o = "结果";
                cache.put(key, o);
            } finally {
                // 加读锁2, 锁降级写锁降为读锁, 这里加读锁就是避免下面的 [释放读锁1] 报错
                readLock.lock();
                // 释放写锁2 (这里一定要释放, 否则会锁死)
                writeLock.unlock();
            }
        }

        // 释放[读锁1]或者[读锁2]
        readLock.unlock();
        return o;
    }

    @Override
    public void run() {
        Object res = getVal(key);
        // Object res = getValue(key);
        // System.out.println("获取结果: " + res);
    }

    public static void main(String[] args) {
        // 注意点一: 加了锁记得及时释放
        // 注意点二: 读读不互斥(共享锁), 读写互斥(排他锁), 写写互斥(排他锁)

        // 读读不互斥(共享锁): 一个线程进来加了读锁, 第二个线程还能进来读该资源
        // 读写互斥(排他锁): 一个线程进来加了读锁, 第二个线程进来就加不了写锁, 需要等待第一个线程释放读锁
        // 写写互斥(排他锁): 一个线程进来加了写锁, 第二个线程进来就加不了写锁, 需要等待第一个线程释放写锁
        // 锁降级: 第一个线程先加了`写锁`，接着在保持`写锁`的同时尝试获取读锁，如果成功获取`读锁`，线程释放写锁，此时线程只持有读锁

        for (int i = 0; i < 10; i++) {
            // 可以被2整除使用key1, 否则使用 key2
            new TestCache(i % 2 == 0 ? "key1" : "key2").start();
        }

    }

}

到这里就完成了，核心代码

public static Object getVal(String key) {
        // 加读锁1
        readLock.lock();
        System.out.println("[" + key + "]线程" + Thread.currentThread().getId() + "进入读锁");
        Object o = cache.get(key);
        if (o != null) {
            // 释放读锁1
            readLock.unlock();
            return o;
        }

        // 释放读锁1, 避免下面写锁会锁死
        readLock.unlock();
        // 加写锁2
        writeLock.lock();
        try {
            System.out.println("[" + key + "]线程" + Thread.currentThread().getId() + "进入[写锁]!");
            // 这里可以做业务查询数据并写入
            o = "结果";
            cache.put(key, o);
        } finally {
            // 释放写锁2
            writeLock.unlock();
        }
        return o;
}