内存级缓存ConcurrentSkipListMap实现方式

Myth丶恋晨 2021-12-09 07:29 128阅读 0赞

适用于复杂业务提高性能。

适用场景：

1.外部传输一个200以上属性的JSON，我们只需要在一系列负责业务后取其中50个属性使用，即可把初始的JSON字符串压缩后放入Map，给一个过期时间，等后续业务使用时直接从Map获取。

2.系统中的一些常量、字典、等都可以在程序初始化时放入。使用时直接获取。比Redis更轻量级。

代码一共四个类：

![2019071616231233.png][]

![2019071616233835.png][]

**一、CacheEntity 类**

import java.io.Serializable;
 import lombok.Builder;
 import lombok.Data;
 
 /**
 * CacheEntity Description: 内存级缓存实体类，必须有过期时间，禁止长期有效的数据出现；
 * @author douzi
 * DATE 2019年7月15日 下午3:47:28
 */
 @Data
 @Builder
 public class CacheEntity implements Serializable {
 	/**
 	 * Fields serialVersionUID :
 	 */
 	private static final long serialVersionUID = 7449985759453960984L;
 
 	/**
 	 * Fields key : 唯一键
 	 */
 	private String key;
 	
 	/**
 	 * value : 值
 	 */
 	private String value;
 	
 	/**
 	 * Fields timestamp : 缓存的时候存的时间戳，用来计算该元素是否过期
 	 */
 	private Long timestamp;
 	
 	/**
 	 * Fields expire : 有效期 秒 0为无限
 	 */
 	private int expire;
 	
 	/**
 	 * Title: remainTime
 	 * Description: 获取剩余时间（秒）
 	 * @author douzi
 	 * @return
 	 */
 	public int remainTime() {
 		if (this.expire == 0) {
 			return this.expire;
 		}
 		return this.expire - getTime();
 	}
 	
 	/**
 	 * Title: getTime
 	 * Description: 获取当前时间和缓存时间戳差值（秒） 
 	 * @author douzi
 	 * @return
 	 */
 	private int getTime() {
 		if (this.expire == 0) {
 			return this.expire;
 		}
 		Long current = System.currentTimeMillis();
 		Long value = current - this.timestamp;
 		return (int) (value / 1000) + 1;
 	}
 
 	/**
 	 * Title: isExpire
 	 * Description: 判断缓存是否到期 false：不到期 true：到期
 	 * @author douzi
 	 * @return
 	 */
 	public boolean isExpire() {
 		if (this.expire == 0) {
 			return false;
 		}
 //		log.info(getTime() + " " + expire);
 		if (getTime() > this.expire) {
 			return true;
 		}
 		return false;
 	}
 }

**二、MemoryCache类**

import java.util.LinkedList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentSkipListMap;
 
 import com.wondertek.oes.bc.common.utils.GZIPUtils;
 
 import lombok.extern.slf4j.Slf4j;
 
 /**
 * MemoryCache Description: 内存级缓存类,自带压缩功能、自动清除过期时间功能
 * @author douzi
 * DATE 2019年7月15日 下午3:17:04
 */
 @Slf4j
 public class MemoryCache {
 	/** 饿汉式单例 */
 //	private static final Map<String, CacheEntity> cache = new ConcurrentHashMap<String, CacheEntity>();
 //	private static final Map<String, CacheEntity> cache = new ConcurrentSkipListMap<String, CacheEntity>();
 	/** Initialization Demand Holder (IoDH) 技术，单例类中增加一个静态(static)内部类，既可以实现延迟加载，又可以保证线程安全，不影响系统性能 */
 	private static class HolderClass {
 		//跳表实现 类似redis数据结构，空间换时间加快速度
 		private static final Map<String, CacheEntity> cache = new ConcurrentSkipListMap<String, CacheEntity>();
 	}
 	
 	private MemoryCache() {
 	}
 	
 /**
 * 清理过期缓存是否在运行
 */
 	public static volatile Boolean CLEAN_THREAD_IS_RUN = false;
 
 /**
 * 清理缓存间隔时间以及默认过期时间 秒
 */
 static final int DEFALUT_EXPIRE = 60;
 
 /**
 * 是否压缩
 */
 public static volatile Boolean IS_ZIP = true;
 
 /**
 * Title: clear
 * Description: 清空全部缓存，项目启动时使用或实际业务中不建议使用
 * @author douzi
 */
 public static void clearAll() {
 HolderClass.cache.clear();
 }
 
 /**
 * Title: getAll
 * Description: 获取所有数据
 * @author douzi
 * @return
 */
 public static Map<String, CacheEntity> getAll() {
 	return HolderClass.cache;
 }
 
 /**
 * Title: size
 * Description: 获取缓存大小
 * @author douzi
 * @return
 */
 public static int size() {
 	return HolderClass.cache.size();
 }
 
 /**
 * Title: get
 * Description: 获取对象
 * @author douzi
 * @param key 键
 * @return
 */
 public static String get(String key) {
 	if (checkCache(key)) {
 		CacheEntity entity = HolderClass.cache.get(key);
 	if (IS_ZIP) {
 		return GZIPUtils.uncompress(entity.getValue());
 	}
 		return entity.getValue();
 	}
 	return null;
 }
 
 /**
 * Title: checkCache
 * Description: 判断缓存在不在,过没过期
 * @author douzi
 * @param key
 * @return
 */
 public static boolean checkCache(String key) {
 	CacheEntity entity = HolderClass.cache.get(key);
 if (entity == null) {
 return false;
 }
 if (entity.isExpire()) {
 return false;
 }
 return true;
 }
 
 /**
 * Title: removeCache
 * Description: 清除对应的对象
 * @author douzi
 * @param key 键
 */
 	public static void removeCache(String key){
 		log.info("remove key:" + key);
 		HolderClass.cache.remove(key);
 	}
 	
 	/**
 	 * Title: put
 	 * Description: 放置缓存
 	 * @author douzi
 	 * @param key 键
 	 * @param json 值
 	 */
 	public static void put(String key, String json) {
 		put(key, json, DEFALUT_EXPIRE - 1);
 	}
 	
 	/**
 	 * Title: put
 	 * Description: 放置缓存
 	 * @author douzi
 	 * @param key 键
 	 * @param json 值
 	 * @param expire 过期时间（秒） 0为永久
 	 */
 	public static void put(String key, String json, int expire) {
 		if (IS_ZIP) {
 			json = GZIPUtils.compress(json);
 	 }
 		CacheEntity entity = CacheEntity.builder()	 .key(key).value(json).timestamp(System.currentTimeMillis()).expire(expire)
 .build();
 		HolderClass.cache.put(key, entity);
 		startCleanThread();
 		log.info("put json to cache key:" + key + " expire:" + expire + " size: " + json.length());
 	}
 	
 	/**
 	 * Title: clearExpireEntity
 	 * Description: 清除所有的过期对象
 	 * @author douzi
 	 */
 	public static void clearExpireEntity() {
 List<String> deleteKeyList = new LinkedList<>();
 for(Map.Entry<String, CacheEntity> entry : HolderClass.cache.entrySet()) {
 if (entry.getValue().isExpire()) {
 	deleteKeyList.add(entry.getKey());
 }
 }
 
 for (String deleteKey : deleteKeyList) {
 	removeCache(deleteKey);
 		}
 		log.info("delete cache count is :" + deleteKeyList.size());
 	}
 	
 	/**
 	 * Title: startCleanThread
 	 * Description: 开启清理过期缓存的线程
 	 * @author douzi
 	 */
 private static void startCleanThread() {
 if (!CLEAN_THREAD_IS_RUN) {
 	 CleanTimeOutThread cleanTimeOutThread = new CleanTimeOutThread();
 	 Thread thread = new Thread(cleanTimeOutThread, "memory-cache-clean");
 	 /** 设置为后台守护线程 */
 	 thread.setDaemon(true);
 	 thread.start();
 }
 }
 }

**三、CleanTimeOutThread 类**

import lombok.extern.slf4j.Slf4j;
 
 /**
 * CleanTimeOutThread Description: 清除内存缓存过期数据
 * @author douzi
 * DATE 2019年7月15日 下午4:58:11
 */
 @Slf4j
 public class CleanTimeOutThread implements Runnable {
 
 	@Override
 	public void run() {
 		log.info("===MemoryCache clean thread run===");
 		MemoryCache.CLEAN_THREAD_IS_RUN = true;
 		while(true) {
 			try {
 Thread.sleep(MemoryCache.DEFALUT_EXPIRE * 1000);
 } catch (InterruptedException e) {
 e.printStackTrace();
 log.error("===MemoryCache clean thread down===");
 MemoryCache.CLEAN_THREAD_IS_RUN = false;
 Thread.currentThread().interrupt();
 }
 			MemoryCache.clearExpireEntity();
 	 }
 	}
 
 }

**四、压缩类是网上拷贝 GZIPUtils 类**

import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;
 
 import cn.hutool.core.io.IoUtil;
 
 /**
 * GZIPUtils Description: 压缩解压缩类
 * @author douzi
 * DATE 2019年7月15日 下午11:26:04
 */
 public class GZIPUtils {
 	/**
 * 使用gzip进行压缩
 */
 @SuppressWarnings("restriction")
 	public static String compress(String primStr) {
 if (primStr == null || primStr.length() == 0) {
 return primStr;
 }
 //不需要关流
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 GZIPOutputStream gzip = null;
 try {
 gzip = new GZIPOutputStream(out);
 gzip.write(primStr.getBytes());
 } catch (IOException e) {
 e.printStackTrace();
 } finally {
 IoUtil.close(gzip);
 }
 return new sun.misc.BASE64Encoder().encode(out.toByteArray());
 }
 
 /**
 * 使用gzip进行解压缩
 */
 @SuppressWarnings("restriction")
 	public static String uncompress(String compressedStr) {
 if (compressedStr == null) {
 return null;
 }
 ByteArrayOutputStream out = new ByteArrayOutputStream();
 ByteArrayInputStream in = null;
 GZIPInputStream ginzip = null;
 byte[] compressed = null;
 String decompressed = null;
 try {
 compressed = new sun.misc.BASE64Decoder().decodeBuffer(compressedStr);
 in = new ByteArrayInputStream(compressed);
 ginzip = new GZIPInputStream(in);
 
 byte[] buffer = new byte[1024];
 int offset = -1;
 while ((offset = ginzip.read(buffer)) != -1) {
 out.write(buffer, 0, offset);
 }
 decompressed = out.toString();
 } catch (IOException e) {
 e.printStackTrace();
 } finally {
 IoUtil.close(ginzip);
 IoUtil.close(in);
 IoUtil.close(out);
 }
 return decompressed;
 }
 }

五、测试类

import org.apache.commons.lang3.time.StopWatch;
 import com.wondertek.oes.bc.common.cache.MemoryCache;
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
 public class MemoryCacheTest {
 	
 	public static void main(String[] args) {
 		StopWatch sw = new StopWatch();
 		sw.start();
 		String aa = "douzi1111";
 		for (int i = 0; i < 200; i++) {
 			aa += " douzi1111 " + i;
 		}
 		//是否打开压缩
 //		MemoryCache.IS_ZIP = false;
 for (int i = 0; i < 2000; i ++ ) {
 			MemoryCache.put("douzi" + i, aa);
 }
 		sw.stop();
 		log.info("size:" + MemoryCache.size() + " " + aa.length() + " 时长："+ sw.getTime()+ " douzi: " + MemoryCache.get("douzi1"));
 		while (true) {
 			try {
 				Thread.sleep(10000); //10秒获取一次
 			} catch (InterruptedException e) {
 				e.printStackTrace();
 			}
 			log.info("size1:" + MemoryCache.size() + " douzi: " + MemoryCache.get("douzi1"));
 			if(!MemoryCache.checkCache("douzi1")) {
 				break;
 			}
 		}
 	}
 }

压缩的情况下结果：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MTE2NTQ5_size_16_color_FFFFFF_t_70][]

[2019071616231233.png]: /images/20211208/ac416fc037ed44e8a97afbd039b3be90.png
[2019071616233835.png]: /images/20211208/d7a58f13cb1341938ca9e2a6278f5c3d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzE2MTE2NTQ5_size_16_color_FFFFFF_t_70]: /images/20211208/a3a1c157eb38451383d4f45c8cdbe2c1.png