java map 缓存_缓存用于

大家好，又见面了，我是你们的朋友全栈君。如果您正在找激活码,请点击查看最新教程,关注关注公众号 “全栈程序员社区” 获取激活教程,可能之前旧版本教程已经失效.最新Idea2022.1教程亲测有效,一键激活。

Jetbrains全系列IDE稳定放心使用

缓存

什么是缓存？
平常的开发项目中，多多少少都会使用到缓存，因为一些数据我们没有必要每次查询的时候都去查询到数据库。

缓存的使用场景：
在Java应用中，对于访问频率高，更新少的数据，通常的方案是将这类数据加入缓存中，相对从数据库中读取，读缓存效率会有很大提升。
在集群环境下，常用的分布式缓存有Redis等。但在某些业务场景上，可能不需要去搭建一套复杂的分布式缓存系统，在单机环境下，通常是会希望使用内部的缓存(LocalCache)。

使用map缓存

方案：

基于ConcurrentHashMap实现数据缓存，实现线程安全要求
SoftReference：当内存不够的时候，GC会回收SoftReference所引用的对象

SoftReference是软引用，它保存的对象实例，除非JVM即OutOfMemory，否则不会被GC回收。这个特性使得它特别适合设计对象Cache。对于Cache，我们希望被缓存的对象最好始终常驻内存，但是如果JVM内存吃紧，为了不发生OutOfMemoryError导致系统崩溃，必要的时候也允许JVM回收Cache的内存，待后续合适的时机再把数据重新Load到Cache中。这样可以系统设计得更具弹性。

代码如下：

/** * 使用map做缓存 */
public class MapCache { 
   
	//定义扫描时间参数
    private static final int CLEAN_TIME_PARAMETER = 5;

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

	/** * 在构造函数中，创建一个守护程序线程，每5秒扫描一次并清理过期的对象。 */
    public MapCache(){ 
   
        Thread cleanerThread = new Thread(()->{ 
   
            //获取线程中断状态
            while (!Thread.currentThread().isInterrupted()) { 
   
                try { 
   
                    Thread.sleep(CLEAN_TIME_PARAMETER * 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;
        }
    }
}

测试类：

public class Test { 
   
    public static void main(String[] args) throws InterruptedException { 
   
        MapCache mapCache = new MapCache();
        mapCache.add("10001", "111111", 5 * 1000);
        mapCache.add("10002", "222222", 5 * 1000);
        mapCache.add("10003", "333333", 5 * 1000);
        System.out.println("从缓存中取出值:" + mapCache.get("10001"));
        Thread.sleep(5000L);
        System.out.println("5秒钟过后");
        // 5秒后数据自动清除了
        System.out.println("从缓存中取出值:" + mapCache.get("10001"));
     
    }
}