本地缓存与分布式缓存-手动实现一个缓存系统_内存缓存和分布式缓存可以同时使用嘛

缓存是什么，有什么作用？

缓存（Cache）是指将程序或系统中常用的数据对象存储在像内存这样特定的介质中，以避免在每次程序调用时，重新创建或组织数据所带来的性能损耗，从而提高了系统的整体运行速度。

以目前的系统架构来说，用户的请求一般会先经过缓存系统，如果缓存中没有相关的数据，就会在其他系统中查询到相应的数据并保存在缓存中，最后返回给调用方。

本地缓存

程序级别的缓存组件，特点是本地缓存和应用程序会在运行同一个进程中，本地缓存的操作特别快，在同一个进程中不会有网络上的延迟和开销。

本地缓存适用于单节点非集群的应用场景，它的优点是快，缺点是多程序无法共享缓存，比如分布式用户 Session 会话信息保存，由于每次用户访问的服务器可能是不同的，如果不能共享缓存，那么就意味着每次的请求操作都有可能被系统阻止，因为会话信息只保存在某一个服务器上，当请求没有被转发到这台存储了用户信息的服务器时，就会被认为是非登录的违规操作。

除此之外，无法共享缓存可能会造成系统资源的浪费，这是因为每个系统都单独维护了一份属于自己的缓存，而同一份缓存有可能被多个系统单独进行存储，从而浪费了系统资源。

可以使用EhCache和Google的Guava来实现

EhCache和Guava的使用及特点分析

EhCache 支持内存缓存和磁盘缓存，支持 LRU（Least Recently Used，最近很少使用）、LFU（Least Frequently Used，最近不常被使用）和 FIFO（First In First Out，先进先出）等多种淘汰算法，并且支持分布式的缓存系统。

EhCache 最初是独立的本地缓存框架组件，在后期的发展中（从 1.2 版）开始支持分布式缓存，分布式缓存主要支持 RMI、JGroups、EhCache Server 等方式。

LRU算法有一个缺点，比如说很久没有使用的一个键值，如果最近被访问了一次，那么即使它是使用次数最少的缓存，它也不会被淘汰；而 LFU 算法解决了偶尔被访问一次之后，数据就不会被淘汰的问题，它是根据总访问次数来淘汰数据的，其核心思想是“如果数据过去被访问多次，那么将来它被访问次数也会比较多”。因此 LFU 可以理解为比 LRU 更加合理的淘汰算法。

在maven项目中配置

<!-- https://mvnrepository.com/artifact/org.ehcache/ehcache -->

<dependency>

    <groupId>org.ehcache</groupId>

    <artifactId>ehcache</artifactId>

    <version>3.8.1</version>

</dependency>

1
2
3
4
5
6
7
8
9
10
11
12

EhCache使用

import org.ehcache.Cache;
import org.ehcache.CacheManager;
import org.ehcache.config.builders.CacheConfigurationBuilder;
import org.ehcache.config.builders.CacheManagerBuilder;
import org.ehcache.config.builders.ResourcePoolsBuilder;

public class EhcacheLearn {
    public static void main(String[] args) {
        //创建缓存管理器
        CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder().build();
        //初始化 Ehcache
        cacheManager.init();
        //创建缓存（存储器）
        Cache<String, String> tangTangIsLearning = cacheManager.createCache("TangTangIsLearning",
                CacheConfigurationBuilder.newCacheConfigurationBuilder(String.class, String.class, ResourcePoolsBuilder.heap(10)));//设置缓存的最大容量
        //设置缓存
        tangTangIsLearning.put("key","value");
        //读取缓存
        String value = tangTangIsLearning.get("key");
        System.out.println(value);
        //关闭缓存
        cacheManager.close();


    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

CacheManager：是缓存管理器，可以通过单例或者多例的方式创建，也是 Ehcache 的入口类；

Cache：每个 CacheManager 可以管理多个 Cache，每个 Cache 可以采用 hash 的方式存储多个元素。

它们的关系如下图所示：

EhCache 的特点是，它使用起来比较简单，并且本身的 jar 包不是不大，简单的配置之后就可以正常使用了。EhCache 的使用比较灵活，它支持多种缓存策略的配置，它同时支持内存和磁盘缓存两种方式，在 EhCache 1.2 之后也开始支持分布式缓存了。

Guava Cache 是 Google 开源的 Guava 里的一个子功能，它是一个内存型的本地缓存实现方案，提供了线程安全的缓存操作机制。

Guava Cache 的架构设计灵感来源于 ConcurrentHashMap，它使用了多个 segments 方式的细粒度锁，在保证线程安全的同时，支持了高并发的使用场景。Guava Cache 类似于 Map 集合的方式对键值对进行操作，只不过多了过期淘汰等处理逻辑。

分布式缓存

分布式缓存是指将应用和缓存组件进行分离的缓存机制，这样多个应用系统就可以共享一套缓存数据了，它的特点是共享缓存服务和可集群部署，为缓存系统提供了高可用的运行环境，以及缓存共享的程序运行机制。

使用Redis或者Memcached。由于 Redis 本身就是独立的缓存系统，因此可以作为第三方来提供共享的数据缓存，而 Redis 的分布式支持主从、哨兵和集群的模式，所以它就可以支持分布式的缓存，而 Memcached 的情况也是类似的。

手动实现一个缓存系统

目前常见的过期策略有三种

定时删除

是指在设置键值的过期时间时，创建一个定时事件，当到达过期时间后，事件处理器会执行删除过期键的操作。它的优点是可以及时的释放内存空间，缺点是需要开启多个延迟执行事件来处理清除任务，这样就会造成大量任务事件堆积，占用了很多系统资源。

惰性删除

不会主动删除过期键，而是在每次请求时才会判断此值是否过期，如果过期则删除键值，否则就返回正常值。它的优点是只会占用少量的系统资源，缺点是清除不够及时，会造成一定的空间浪费。

定期删除

是指每隔一段时间检查一次数据库，随机删除一些过期键值。

Redis使用惰性删除与定期删除两种策略。

首先需要定义一个存放缓存值的实体类，这个类里包含了缓存的相关信息，比如缓存的 key 和 value，缓存的存入时间、最后使用时间和命中次数（预留字段，用于支持 LFU 缓存淘汰），再使用 ConcurrentHashMap 保存缓存的 key 和 value 对象（缓存值的实体类），然后再新增一个缓存操作的工具类，用于添加和删除缓存，最后再缓存启动时，开启一个线程用于检测并删除过期的缓存，实现代码如下。

实体类代码：

import lombok.Getter;
import lombok.Setter;

import java.util.Comparator;

@Setter
@Getter
public class MyCacheEntity implements Comparable<MyCacheEntity> {
    private Object key;
    private Object value;
    private long lastTime;
    private long writeTime;
    private long  expireTime;
    private Integer hitCount;


    @Override
    public int compareTo(MyCacheEntity o) {
        return hitCount.compareTo(o.hitCount);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

定义缓存对象

import java.util.concurrent.ConcurrentHashMap;

public class CacheGlobal {
    //全局缓存对象
    public static ConcurrentHashMap<String,MyCacheEntity> concurrentHashMap=new ConcurrentHashMap<>();
}
1
2
3
4
5
6

缓存工具类，有删除和更新的功能

import org.apache.commons.lang3.StringUtils;

public class CacheUtils {
    /**
     * 添加缓存
     * @param key
     * @param value
     * @param expire
     */
    public void put(String key, Object value, long expire) {
        // 非空判断，借助 commons-lang3
        if (StringUtils.isBlank(key)) return;
        // 当缓存存在时，更新缓存
        if (CacheGlobal.concurrentHashMap.containsKey(key)) {
            MyCacheEntity cache = CacheGlobal.concurrentHashMap.get(key);
            cache.setHitCount(cache.getHitCount() + 1);
            cache.setWriteTime(System.currentTimeMillis());
            cache.setLastTime(System.currentTimeMillis());
            cache.setExpireTime(expire);
            cache.setValue(value);
            return;
        }
        // 创建缓存
        MyCacheEntity cache = new MyCacheEntity();
        cache.setKey(key);
        cache.setValue(value);
        cache.setWriteTime(System.currentTimeMillis());
        cache.setLastTime(System.currentTimeMillis());
        cache.setHitCount(1);
        cache.setExpireTime(expire);
        CacheGlobal.concurrentHashMap.put(key, cache);
    }
    /**
     * 获取缓存
     * @param key
     * @return
     */
    public Object get(String key) {
        // 非空判断
        if (StringUtils.isBlank(key)) return null;
        // 字典中不存在
        if (CacheGlobal.concurrentHashMap.isEmpty()) return null;
        if (!CacheGlobal.concurrentHashMap.containsKey(key)) return null;
        MyCacheEntity cache = CacheGlobal.concurrentHashMap.get(key);
        if (cache == null) return null;
        // 惰性删除，判断缓存是否过期
        long timoutTime = System.currentTimeMillis() - cache.getWriteTime();
        // 缓存过期
        if (cache.getExpireTime() <= timoutTime) {
            // 清除过期缓存
            CacheGlobal.concurrentHashMap.remove(key);
            return null;
        }
        cache.setHitCount(cache.getHitCount() + 1);
        cache.setLastTime(System.currentTimeMillis());
        return cache.getValue();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59

缓存检验是否过期10s间隔，过期清除

import java.util.concurrent.TimeUnit;

public class ExpireThread implements Runnable {


    @Override
    public void run() {
        int i=0;
        while (i<2)
            try {
                //每10s检查一次
                TimeUnit.SECONDS.sleep(10);
                expireCache();
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                i++;
            }
    }

    /*缓存检测和清除方法*/
    private void expireCache()
    {
        System.out.println("检测缓存是否过期");
        for (String key : CacheGlobal.concurrentHashMap.keySet()) {
            MyCacheEntity cache = CacheGlobal.concurrentHashMap.get(key);
            //当前时间减去写入时间
            long timOutTime= System.currentTimeMillis() - cache.getWriteTime();
            if(cache.getExpireTime()>timOutTime)
            {
                //没有过期
                continue;
            }
            //清除过期缓存
            CacheGlobal.concurrentHashMap.remove(key);
        }

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

测试类

import java.util.concurrent.TimeUnit;

public class MyCacheTest {
    public static void main(String[] args) throws InterruptedException {
        CacheUtils cache=new CacheUtils();
        cache.put("name","TangTang",10);
        String name = (String) cache.get("name");
        System.out.println(name);
        String sex = (String) cache.get("Sex");
        System.out.println(sex);
        new ExpireThread().run();
        TimeUnit.SECONDS.sleep(13);
        String name2 = (String) cache.get("name");
        System.out.println(name2);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17