实现 Java 本地缓存(转)

转载的内容
缓存,我相信大家对它一定不陌生,在项目中,缓存肯定是必不可少的。市面上有非常多的缓存工具,比如 Redis、Guava Cache 或者 EHcache。对于这些工具,我想大家肯定都非常熟悉,所以今天我们不聊它们,我们来聊一聊如何实现本地缓存。参考上面几种工具,要实现一个较好的本地缓存,平头哥认为要从以下三个方面开始。

  • 1、存储集合的选择

实现本地缓存,存储容器肯定是 key/value 形式的数据结构,在 Java 中,也就是我们常用的 Map 集合。Map 中有 HashMap、Hashtable、ConcurrentHashMap 几种供我们选择,如果不考虑高并发情况下数据安全问题,我们可以选择HashMap,如果考虑高并发情况下数据安全问题,我们可以选择 Hashtable、ConcurrentHashMap 中的一种集合,但是我们优先选择 ConcurrentHashMap,因为 ConcurrentHashMap 的性能比 Hashtable 要好。

  • 2、过期缓存处理

因为缓存直接存储在内存中,如果我们不处理过期缓存,内存将被大量无效缓存占用,这不是我们想要的,所以我们需要清理这些失效的缓存。过期缓存处理可以参考 Redis 的策略来实现,Redis 采用的是定期删除 + 懒惰淘汰策略。

  • 定期删除策略

定期删除策略是每隔一段时间检测已过期的缓存,并且降之删除。这个策略的优点是能够确保过期的缓存都会被删除。同时也存在着缺点,过期的缓存不一定能够及时的被删除,这跟我们设置的定时频率有关系,另一个缺点是如果缓存数据较多时,每次检测也会给 cup 带来不小的压力。

  • 懒惰淘汰策略

懒惰淘汰策略是在使用缓存时,先判断缓存是否过期,如果过期将它删除,并且返回空。这个策略的优点是只有在查找的时候,才判断是否过期,对 CUP 影响较。同时这种策略有致命的缺点,当存入了大量的缓存,这些缓存都没有被使用并且已过期,都将成为无效缓存,这些无效的缓存将占用你大量的内存空间,最后导致服务器内存溢出。

我们简单的了解了一下 Redis 的两种过期缓存处理策略,每种策略都存在自己的优缺点。所以我们在使用过程中,可以将两种策略组合起来,结合效果还是非常理想的。

  • 3、缓存淘汰策略

缓存淘汰跟过期缓存处理要区别开来,缓存淘汰是指当我们的缓存个数达到我们指定的缓存个数时,毕竟我们的内存不是无限的。如果我们需要继续添加缓存的话,我们就需要在现有的缓存中根据某种策略淘汰一些缓存,给新添加的缓存腾出位置,下面一起来认识几种常用的缓存淘汰策略。

  • 先进先出策略

最先进入缓存的数据在缓存空间不够的情况下会被优先被清除掉,以腾出新的空间接受新的数据。该策略主要比较缓存元素的创建时间。在一些对数据实效性要求比较高的场景下,可考虑选择该类策略,优先保障最新数据可用。

  • 最少使用策略

无论是否过期,根据元素的被使用次数判断,清除使用次数较少的元素释放空间。该策略主要比较元素的hitCount(命中次数),在保证高频数据有效性场景下,可选择这类策略。

  • 最近最少使用策略

无论是否过期,根据元素最后一次被使用的时间戳,清除最远使用时间戳的元素释放空间。该策略主要比较缓存最近一次被get使用时间。在热点数据场景下较适用,优先保证热点数据的有效性。

  • 随机淘汰策略

无论是否过期,随机淘汰某个缓存,如果对缓存数据没有任何要求,可以考虑使用该策略。

  • 不淘汰策略

当缓存达到指定值之后,不淘汰任何缓存,而是不能新增缓存,直到有缓存淘汰时,才能继续添加缓存。

上面是实现本地缓存需要考虑的三个点,看完我们应该知该如何实现一个本地缓存了,不妨我们一起来实现一个本地缓存。

  • 实现本地缓存

在该 Demo 中,我们采用 ConcurrentHashMap 作为存储集合,这样即使在高并发的情况下,我们也能够保证缓存的安全。过期缓存处理在这里我只使用了定时删除策略,并没有使用定时删除 + 懒惰淘汰策略,你可以自己动手尝试一下使用这两种策略进行过期缓存处理。在缓存淘汰方面,我在这里采用了最少使用策略。好了,技术选型都知道了,我们一起来看看代码实现。

  • 缓存对象类

      public class Cache implements Comparable<Cache>{
          // 键
          private Object key;
          // 缓存值
          private Object value;
          // 最后一次访问时间
          private long accessTime;
          // 创建时间
          private long writeTime;
          // 存活时间
          private long expireTime;
          // 命中次数
          private Integer hitCount;
          ...getter/setter()...
    
  • 添加缓存

    /**
     * 添加缓存
     *
     * @param key
     * @param value
     */
    public void put(K key, V value,long expire) {
        checkNotNull(key);
        checkNotNull(value);
        // 当缓存存在时,更新缓存
        if (concurrentHashMap.containsKey(key)){
            Cache cache = concurrentHashMap.get(key);
            cache.setHitCount(cache.getHitCount()+1);
            cache.setWriteTime(System.currentTimeMillis());
            cache.setAccessTime(System.currentTimeMillis());
            cache.setExpireTime(expire);
            cache.setValue(value);
            return;
        }
        // 已经达到最大缓存
        if (isFull()) {
            Object kickedKey = getKickedKey();
            if (kickedKey !=null){
                // 移除最少使用的缓存
                concurrentHashMap.remove(kickedKey);
            }else {
                return;
            }
        }
        Cache cache = new Cache();
        cache.setKey(key);
        cache.setValue(value);
        cache.setWriteTime(System.currentTimeMillis());
        cache.setAccessTime(System.currentTimeMillis());
        cache.setHitCount(1);
        cache.setExpireTime(expire);
        concurrentHashMap.put(key, cache);
    }
    
    • 获取缓存

       /**
        * 获取缓存
        *
        * @param key
        * @return
        */
       public Object get(K key) {
           checkNotNull(key);
           if (concurrentHashMap.isEmpty()) return null;
           if (!concurrentHashMap.containsKey(key)) return null;
           Cache cache = concurrentHashMap.get(key);
           if (cache == null) return null;
           cache.setHitCount(cache.getHitCount()+1);
           cache.setAccessTime(System.currentTimeMillis());
           return cache.getValue();
       }
       获取最少使用的缓存
       
           /**
            * 获取最少使用的缓存
            * @return
            */
           private Object getKickedKey() {
               Cache min = Collections.min(concurrentHashMap.values());
               return min.getKey();
           }
       过期缓存检测方法
       
       /**
        * 处理过期缓存
        */
       class TimeoutTimerThread implements Runnable {
           public void run() {
               while (true) {
                   try {
                       TimeUnit.SECONDS.sleep(60);
                       expireCache();
                   } catch (Exception e) {
                       e.printStackTrace();
                   }
               }
           }
       
           /**
            * 创建多久后,缓存失效
            *
            * @throws Exception
            */
           private void expireCache() throws Exception {
               System.out.println("检测缓存是否过期缓存");
               for (Object key : concurrentHashMap.keySet()) {
                   Cache cache = concurrentHashMap.get(key);
                   long timoutTime = TimeUnit.NANOSECONDS.toSeconds(System.nanoTime()
                           - cache.getWriteTime());
                   if (cache.getExpireTime() > timoutTime) {
                       continue;
                   }
                   System.out.println(" 清除过期缓存 :" + key);
                   //清除过期缓存
                   concurrentHashMap.remove(key);
               }
           }
       }
      

GitHub:本地缓存

本文从实现本地缓存的设计角度,一起简单的探讨了一下实现本地缓存需要注意的地方,其实这些也是缓存的核心技术,不管是 Redis、Guava Cache 还是 EHcache或者其他缓存工具,它们在实现原理上,跟我们本地缓存的实现原理都差不多。只要我们理解了本地缓存的实现原理,在去学习这些缓存工具,我相信还是会比较轻松的。

©️2020 CSDN 皮肤主题: 大白 设计师: CSDN官方博客 返回首页
实付0元
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值