Java基础——缓存
1、缓存
将程序或系统中常用的数据对象存储在像内存这样特定的介质中，以避免在每次程序调用时，重新创建或组织数据所带来的性能损耗，从而提高了系统的整体运行速度
以目前的系统架构来说，用户的请求一般会先经过缓存系统，如果缓存中没有相关的数据，就会在其他系统中查询到相应的数据并保存在缓存中，最后返回给调用方
2、本地式缓存
本地缓存是指程序级别的缓存组件，它的特点是本地缓存和应用程序会运行在同一个进程中，所以本地缓存的操作会非常快，因为在同一个进程内也意味着不会有网络上的延迟和开销
本地缓存适用于单节点非集群的应用场景，它的优点是快，缺点是多程序无法共享缓存
无法共享缓存可能会造成系统资源的浪费，这是因为每个系统都单独维护了一份属于自己的缓存，而同一份缓存有可能被多个系统单独进行存储，从而浪费了系统资源
本地缓存可以使用 EhCache 和 Google 的 Guava 来实现
EhCache ：
目前比较流行的开源缓存框架，是用纯 Java 语言实现的简单、快速的 Cache 组件
支持内存缓存和磁盘缓存
支持 LRU（Least Recently Used，最近很少使用）、LFU（Least Frequently Used，最近不常被使用）和 FIFO（First In First Out，先进先出）等多种淘汰算法
支持分布式的缓存系统
LRU 和 LFU 的区别：
LRU 算法有一个缺点，比如说很久没有使用的一个键值，如果最近被访问了一次，那么即使它是使用次数最少的缓存，它也不会被淘汰
LFU 算法解决了偶尔被访问一次之后，数据就不会被淘汰的问题，它是根据总访问次数来淘汰数据的，其核心思想是“如果数据过去被访问多次，那么将来它被访问次数也会比较多”
<!-- 引入依赖 -->
<dependency>
<groupId>org.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>3.8.1</version>
</dependency>
// 创建缓存管理器，可以通过单例或者多例的方式创建，也是 Ehcache 的入口类
// 每个 CacheManager 可以管理多个 Cache，每个 Cache 可以采用 hash 的方式存储多个元素
CacheManager cacheManager= CacheManagerBuilder.newCacheManagerBuilder().build(); // 初始化 EhCache cacheManager.init(); // 创建缓存（存储器） Cache<String,String> myCache=cacheManager.createCache("MYCACHE", CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class,String.class, ResourcePoolsBuilder.heap(10)));// 设置缓存的最大容量 // 设置缓存的最大容量 // 设置缓存 myCache.put("key","Hello"); // 读取缓存 String value = myCache.get("key"); // 输出缓存 System.out.println(value); // 关闭缓存 cacheManager.close();
Guava ：
Guava Cache 是 Google 开源的 Guava 里的一个子功能
是一个内存型的本地缓存实现方案，提供了线程安全的缓存操作机制
Guava Cache 的架构设计灵感来源于 ConcurrentHashMap，它使用了多个 segments 方式的细粒度锁，在保证线程安全的同时，支持了高并发的使用场景
Guava Cache 类似于 Map 集合的方式对键值对进行操作，只不过多了过期淘汰等处理逻辑
Guava Cache 的创建有两种方式，一种是 LoadingCache，另一种是 Callable
//添加依赖
<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>28.2-jre</version>
</dependency>
import com.google.common.cache.*;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
public class GuavaExample {
public static void main(String[] args) throws ExecutionException {
// 创建方式一：LoadingCache
LoadingCache<String, String> loadCache = CacheBuilder.newBuilder()
// 并发级别设置为 5，是指可以同时写缓存的线程数
.concurrencyLevel(5)
// 设置 8 秒钟过期
.expireAfterWrite(8, TimeUnit.SECONDS)
//设置缓存容器的初始容量为 10
.initialCapacity(10)
// 设置缓存最大容量为 100，超过之后就会按照 LRU 算法移除缓存项
.maximumSize(100)
// 设置要统计缓存的命中率
.recordStats()
// 设置缓存的移除通知
.removalListener(new RemovalListener<Object, Object>() {
public void onRemoval(RemovalNotification<Object, Object> notification) {
System.out.println(notification.getKey() + " was removed, cause is " + notification.getCause());
}
})
// 指定 CacheLoader，缓存不存在时，可自动加载缓存
.build(
new CacheLoader<String, String>() {
@Override
public String load(String key) throws Exception {
// 自动加载缓存的业务
return "cache-value:" + key;
}
}
);
// 设置缓存
loadCache.put("c1", "Hello, c1.");
// 查询缓存
String val = loadCache.get("c1");
System.out.println(val);
// 查询不存在的缓存
String noval = loadCache.get("noval");
System.out.println(noval);
// 创建方式二：Callable
Cache<String, String> cache = CacheBuilder.newBuilder()
.maximumSize(2) // 设置缓存最大长度
.build();
// 设置缓存
cache.put("k1", "Hello, k1.");
// 查询缓存
String value = cache.get("k1", new Callable<String>() {
@Override
public String call() {
// 缓存不存在时，执行
return "nil";
}
});
// 输出缓存值
System.out.println(value);
// 查询缓存
String nokey = cache.get("nokey", new Callable<String>() {
@Override
public String call() {
// 缓存不存在时，执行
return "nil";
}
});
// 输出缓存值
System.out.println(nokey);
}
}3、分布式缓存
指将应用系统和缓存组件进行分离的缓存机制，这样多个应用系统就可以共享一套缓存数据了，它的特点是共享缓存服务和可集群部署，为缓存系统提供了高可用的运行环境，以及缓存共享的程序运行机制
分布式缓存可以使用 Redis 或 Memcached 来实现
4、手写一个缓存
（1）考虑存储数据的模型，并发情况下可以使用 Hashtable 或 ConcurrentHashMap，非并发的情况下可以使用HashMap
（2）缓存数据的有效时间、缓存淘汰
/**
* 缓存实体类，实现Comparable接口，重写compareTo方法
*/
public class CacheValue implements Comparable<CacheValue> {
//缓存键
private Object key;
//缓存值
private Object value;
//最后访问时间
private long lastTime;
//创建时间
private long writeTime;
//存活时间
private long expireTime;
//命中次数
private Integer hitCount;
public Object getKey() {
return key;
}
public void setKey(Object key) {
this.key = key;
}
public Object getValue() {
return value;
}
public void setValue(Object value) {
this.value = value;
}
public long getLastTime() {
return lastTime;
}
public void setLastTime(long lastTime) {
this.lastTime = lastTime;
}
public long getWriteTime() {
return writeTime;
}
public void setWriteTime(long writeTime) {
this.writeTime = writeTime;
}
public long getExpireTime() {
return expireTime;
}
public void setExpireTime(long expireTime) {
this.expireTime = expireTime;
}
public Integer getHitCount() {
return hitCount;
}
public void setHitCount(Integer hitCount) {
this.hitCount = hitCount;
}
@Override
public int compareTo(CacheValue o) {
return hitCount.compareTo(o.hitCount);
}
}
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
/**
* Cache 全局类
*/
public class CacheGlobal {
// 全局缓存对象
public static ConcurrentMap<String, CacheValue> concurrentMap = new ConcurrentHashMap<>();
}
import java.util.concurrent.TimeUnit;
/*缓存操作类
*/
public class CacheUtils {
/**
*添加缓存
*@paramkey
*@paramvalue
*@paramexpire
*/
public void put(String key,Object value,long expire){
//判断key是否有值
if(key == null && !"".equals(key))
return ;
//当缓存存在时，更新缓存
if(CacheGlobal.concurrentMap.containsKey(key)){
CacheValue cache=CacheGlobal.concurrentMap.get(key);
cache.setHitCount(cache.getHitCount()+1);
cache.setWriteTime(System.currentTimeMillis());
cache.setLastTime(System.currentTimeMillis());
cache.setExpireTime(expire);
cache.setValue(value);
return;
}
//创建缓存
CacheValue cache=new CacheValue();
cache.setKey(key);
cache.setValue(value);
cache.setWriteTime(System.currentTimeMillis());
cache.setLastTime(System.currentTimeMillis());
cache.setHitCount(1);
cache.setExpireTime(expire);
CacheGlobal.concurrentMap.put(key,cache);
}
/**
*获取缓存
*@paramkey
*@return
*/
public Object get(String key){
//判断key是否有值
if(key == null && !"".equals(key))
return null;
//字典中不存在
if(CacheGlobal.concurrentMap.isEmpty() && !CacheGlobal.concurrentMap.containsKey(key))
return null;
CacheValue cache=CacheGlobal.concurrentMap.get(key);
if(cache==null)
return null;
//惰性删除，判断缓存是否过期
long timoutTime= TimeUnit.NANOSECONDS.toSeconds(System.nanoTime()-cache.getWriteTime());
if(cache.getExpireTime()<=timoutTime)
//缓存过期
return null;
//清除过期缓存
CacheGlobal.concurrentMap.remove(key);
cache.setHitCount(cache.getHitCount()+1);
cache.setLastTime(System.currentTimeMillis());
return cache.getValue();
}
}
import java.util.concurrent.TimeUnit;
/**
* 过期缓存检测
*/
public class ExpireThread implements Runnable{
@Override
public void run() {
while(true){
try {
//十秒钟线程检测一次
TimeUnit.SECONDS.sleep(10);
//调用检测方法
expireCache();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void expireCache(){
System.out.println("开始检测缓存是否过期");
for(String key : CacheGlobal.concurrentMap.keySet()){
CacheValue cache = CacheGlobal.concurrentMap.get(key);
//缓存存在时间
long timeouttime = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime() - cache.getWriteTime());
//判断缓存是否过期
if(cache.getExpireTime() > timeouttime){
//没过期，跳出循环
continue;
}
//删除过期缓存
CacheGlobal.concurrentMap.remove(key);
}
}
}测试代码：
public class Test {
public static void main(String[] args){
CacheUtils cache=new CacheUtils();
//存入缓存
cache.put("key","老大",10);
//查询缓存
String val=(String)cache.get("key");
System.out.println(val);
//查询不存在的缓存
String noval=(String)cache.get("noval");
System.out.println(noval);
}
}