一、通过可重入锁写一个阻塞版本的 Map

package org.apache.ibatis.block;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * 阻塞 Map
 */
public class BlockMap {

    private Map<Object, Object> map = new HashMap<>();
    /**
     * 键是 key，值是 ReentrantLock 锁
     */
    private final ConcurrentMap<Object, ReentrantLock> locks = new ConcurrentHashMap<>();
    /**
     * 获取锁的超时时间
     */
    private long timeout;

    public long getTimeout() {
        return timeout;
    }

    public void setTimeout(long timeout) {
        this.timeout = timeout;
    }

    public Object getObject(Object key) {
        acquireLock(key);
        Object value = map.get(key);
        if (value != null) {
            //释放锁
            releaseLock(key);
        }
        return value;
    }

    public void putObject(Object key, Object value) {
        try {
            map.put(key, value);
        } finally {
            //注意：这里释放锁的线程必须和获取锁的是同一个线程！！！否则会报错
            releaseLock(key);
        }
    }

    private void acquireLock(Object key) {
        Lock lock = getLockForKey(key);
        if (timeout > 0) {
            try {
                //尝试获取锁，带超时时长
                boolean acquired = lock.tryLock(timeout, TimeUnit.MILLISECONDS);
                if (!acquired) {
                    throw new RuntimeException("获取锁超时！");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } else {
            //获取锁，不带超时时长
            lock.lock();
        }
    }

    private Lock getLockForKey(Object key) {
        ReentrantLock lock = new ReentrantLock();
        //使用 putIfAbsent() ，保证原子性
        ReentrantLock previousLock = locks.putIfAbsent(key, lock);
        return previousLock == null ? lock : previousLock;
    }

    private void releaseLock(Object key) {
        ReentrantLock lock = locks.get(key);
        //若锁为当前线程持有，则释放锁
        if (lock != null && lock.isHeldByCurrentThread()) {
            lock.unlock();
        }
    }

    public static void main(String[] args) {
        testLock();
    }

    private static void testLock() {
        BlockMap map = new BlockMap();
        new Thread(() -> {
            System.out.println("线程1获取值");
            Object value = map.getObject("1");
            if (value == null) {
                System.out.println("线程1获取值为空，尝试从数据库获取！");
                map.putObject("1", 1);
                System.out.println("线程1从数据库获取值[" + map.getObject("1") + "]并放入缓存！");
            } else {
                System.out.println(value);
            }

        }).start();
        new Thread(() -> {
            System.out.println("线程2获取值");
            System.out.println(map.getObject("1"));
        }).start();
        new Thread(() -> {
            System.out.println("线程3获取值");
            System.out.println(map.getObject("1"));
        }).start();
    }
}