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);
    }
}