本地缓存的实现以及遇到的问题-CSDN博客

2019独角兽企业重金招聘Python工程师标准>>>

先分享下我基于MAP实现的一个本地缓存

package org.hjb.component;

import java.lang.ref.SoftReference;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

/**
 * 本地缓存
 * 
 * 何锦彬 2017.02.24
 */
public class LocalMemory {

	// 数据
	static class CacheData {

		// 过期时间
		private Long invalidTime;

		private Object data;

		public Long getInvalidTime() {
			return invalidTime;
		}

		public void setInvalidTime(Long invalidTime) {
			this.invalidTime = invalidTime;
		}

		public Object getData() {
			return data;
		}

		public void setData(Object data) {
			this.data = data;
		}
	}

	private static Logger logger = LogManager.getLogger(LocalMemory.class);

	// 存储本地缓存数据.用软引用避免OutOfMemoryError
	static Map<String, SoftReference<CacheData>> localData = new ConcurrentHashMap<String, SoftReference<CacheData>>();

	public static final int MAX_SIZE = 10000;

	public static final int WARN_VALUE = 8000;

	/**
	 * @param key
	 *            缓存KEY
	 * @param value
	 *            缓存数据
	 * @param timeOut
	 *            超时时间，单位秒
	 */
	public static void put(String key, Object value, Long timeOut) {

		if (localData.size() >= WARN_VALUE) {
			logger.warn("注意:本地缓存已经达到临界值,size:" + localData.size());
		}
		if (localData.size() > MAX_SIZE) {
			logger.error("超出最大值:" + localData.size());
			return;
		}
		CacheData cacheData = new CacheData();

		long now = System.currentTimeMillis();
		long invalidTime = now + (timeOut * 1000);
		cacheData.setData(value);
		cacheData.setInvalidTime(invalidTime);
		SoftReference<CacheData> refCacheData = new SoftReference<CacheData>(cacheData);
		localData.put(key, refCacheData);

	}

	public static final Object get(String key) {
		SoftReference<CacheData> referenceData = localData.get(key);
		if (referenceData == null) {
			logger.debug("未找到数据，key => {}", key);
		}
		CacheData cacheData = localData.get(key).get();
		if (cacheData == null) {
			logger.debug("未找到数据，key => {}", key);
		}
		Long invalidTime = cacheData.getInvalidTime();
		if (invalidTime == null) {
			return null;
		}
		long now = System.currentTimeMillis();
		if (now > invalidTime) {
			// 清除缓存
			localData.remove(key);
			return null;
		}
		return cacheData.getData();
	}

	public static void put(String key, Object value, long time, TimeUnit unit) {
		put(key, value, unit.toSeconds(time));
	}

	public static void main(String[] args) throws InterruptedException {
		String key = "test";
		Object value = "hello world";
		LocalMemory.put("test", value, 1l);
		System.out.println(LocalMemory.get(key));
		Thread.sleep(2000);
		System.out.println(LocalMemory.get(key));
	}

}

本地缓存

优势：

1，易用，只是比map多了个过期时间，有超时的概念
2，用软引用，可防止对JVM的堆对象造成out memory

3，相对集中缓存不需要进行网络开销，消除RPC

缺点：
1，用的是堆内存。会对JVM的垃圾回收造成影响
2，大小控制只能是通过KEY值的存储数量控制，无法通过控制内存占用大小
3，缺少监控方面的设计
4，没有缓存的移除，定期清除失效缓存
5，缓存穿透的问题，当缓存失效时间时，大量访问到了缓存的传统，压到数据库去了

对于3，4问题可以用google的guava

对于1，ehcache可以用JAVA的直接内存.

对于直接内存这部分不好实现，JAVA只提供了个ByteBuffer.allocateDirect(capacity)的方法去应用直接内存，也就意味着要存入直接内存必须先把整个对象序列号成byte再放入直接内存。

但这样每次都需要序列号与反序列化的开销，而且得全量加载的堆内存引起垃圾回收。ehcache有直接用native方法实现

踩过的坑：