秒懂缓存击穿妙招：互斥锁+逻辑过期，一条龙解决！

2023-05-03 02:35:20

缓存击穿：不容小觑的缓存系统难题

简介

在缓存系统中，缓存击穿是一个让人头疼的问题。当缓存中没有数据，并且多个请求同时到达时，就会导致缓存击穿。为了解决这个问题，业界提出了两种行之有效的解决方案：互斥锁和逻辑过期。

互斥锁：为每个 key 加把锁

互斥锁的原理很简单，就是在缓存中为每个 key 加一把锁。当一个请求来的时候，先尝试获取锁，如果获取成功，则继续执行；如果获取失败，则等待一段时间再重试。这样，就可以防止多个请求同时访问同一个 key，从而导致缓存击穿。

代码示例：

public class CacheWithMutexLock {

    private ConcurrentMap<String, Object> cache = new ConcurrentHashMap<>();

    private Lock lock = new ReentrantLock();

    public Object get(String key) {
        Object value = cache.get(key);
        if (value == null) {
            lock.lock();
            try {
                value = cache.get(key);
                if (value == null) {
                    value = loadFromDB(key);
                    cache.put(key, value);
                }
            } finally {
                lock.unlock();
            }
        }
        return value;
    }

    private Object loadFromDB(String key) {
        // 从数据库中加载数据
        return null;
    }
}

逻辑过期：给缓存数据设置一个过期时间

逻辑过期是指给缓存数据设置一个过期时间。当缓存数据过期后，就会被自动删除。这样，就可以防止缓存数据一直存在，从而导致缓存击穿。

代码示例：

public class CacheWithLogicalExpiration {

    private ConcurrentMap<String, ExpiringValue> cache = new ConcurrentHashMap<>();

    public Object get(String key) {
        ExpiringValue value = cache.get(key);
        if (value == null || value.isExpired()) {
            Object newValue = loadFromDB(key);
            cache.put(key, new ExpiringValue(newValue, 10000));
        }
        return value.getValue();
    }

    private Object loadFromDB(String key) {
        // 从数据库中加载数据
        return null;
    }

    private class ExpiringValue {

        private Object value;

        private long expirationTime;

        public ExpiringValue(Object value, long expirationTime) {
            this.value = value;
            this.expirationTime = expirationTime;
        }

        public Object getValue() {
            return value;
        }

        public boolean isExpired() {
            return System.currentTimeMillis() > expirationTime;
        }
    }
}