Java并发编程的艺术(十五)——基于读写锁的缓存案例

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/lwl2014100338/article/details/82078910

当获取写锁之后，其他线程对于读锁和写锁的获取都被阻塞，只有写锁被释放之后，其他读写锁才能继续；而在读操作中，需要获取读锁，并发访问不会被阻塞；从而提高并发性。

---

示例代码

package com.lwl.concurrency.page5;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 读写锁
 */
public class Cache {
    private static final Map<String, Object>    map = new HashMap<String, Object>();
    private static final ReentrantReadWriteLock rwl = new ReentrantReadWriteLock();
    private static final Lock                   r   = rwl.readLock();
    private static final Lock                   w   = rwl.writeLock();

    public static final Object get(String key) {
        r.lock();
        try {
            return map.get(key);
        } finally {
            r.unlock();
        }
    }

    public static final Object put(String key, Object value) {
        w.lock();
        try {
            return map.put(key, value);
        } finally {
            w.unlock();
        }
    }

    public static final void clear() {
        w.lock();
        try {
            map.clear();
        } finally {
            w.unlock();
        }
    }
}