Java内存缓存-通过Map定制简单缓存

Posted 2022-07-18 mb62caa7d6f2477

场景

在Java应用中，对于访问频率高，更新少的数据，通常的方案是将这类数据加入缓存中，相对从数据库中读取，读缓存效率会有很大提升。

在集群环境下，常用的分布式缓存有Redis、Memcached等。但在某些业务场景上，可能不需要去搭建一套复杂的分布式缓存系统，在单机环境下，通常是会希望使用内部的缓存(LocalCache)。

使用Map来实现一个简单的缓存功能

import java.lang.ref.SoftReference;
import java.util.Optional;
import java.util.concurrent.ConcurrentHashMap;

public class MapCacheDemo 

    /**
     * 使用  ConcurrentHashMap，线程安全的要求。
     * 我使用SoftReference <Object>  作为映射值，因为软引用可以保证在抛出OutOfMemory之前，如果缺少内存，将删除引用的对象。
     * 在构造函数中，我创建了一个守护程序线程，每5秒扫描一次并清理过期的对象。
     */
    private static final int CLEAN_UP_PERIOD_IN_SEC = 5;

    private final ConcurrentHashMap<String, SoftReference<CacheObject>> cache = new ConcurrentHashMap<>();

    public MapCacheDemo() 
        Thread cleanerThread = new Thread(() -> 
            while (!Thread.currentThread().isInterrupted()) 
                try 
                    Thread.sleep(CLEAN_UP_PERIOD_IN_SEC * 1000);
                    cache.entrySet().removeIf(entry ->
                            Optional.ofNullable(entry.getValue())
                                    .map(SoftReference::get)
                                    .map(CacheObject::isExpired)
                                    .orElse(false));
                 catch (InterruptedException e) 
                    Thread.currentThread().interrupt();
                
            
        );
        cleanerThread.setDaemon(true);
        cleanerThread.start();
    

    public void add(String key, Object value, long periodInMillis) 
        if (key == null) 
            return;
        
        if (value == null) 
            cache.remove(key);
         else 
            long expiryTime = System.currentTimeMillis() + periodInMillis;
            cache.put(key, new SoftReference<>(new CacheObject(value, expiryTime)));
        
    

    public void remove(String key) 
        cache.remove(key);
    

    public Object get(String key) 
        return Optional.ofNullable(cache.get(key)).map(SoftReference::get).filter(cacheObject -> !cacheObject.isExpired()).map(CacheObject::getValue).orElse(null);
    

    public void clear() 
        cache.clear();
    

    public long size() 
        return cache.entrySet().stream().filter(entry -> Optional.ofNullable(entry.getValue()).map(SoftReference::get).map(cacheObject -> !cacheObject.isExpired()).orElse(false)).count();
    

    /**
     * 缓存对象value
     */
    private static class CacheObject 
        private Object value;
        private long expiryTime;

        private CacheObject(Object value, long expiryTime) 
            this.value = value;
            this.expiryTime = expiryTime;
        

        boolean isExpired() 
            return System.currentTimeMillis() > expiryTime;
        

        public Object getValue() 
            return value;
        

        public void setValue(Object value) 
            this.value = value;