本篇文章给大家分享的是有关使用Java怎么实现本地缓存，小编觉得挺实用的，因此分享给大家学习，希望大家阅读完这篇文章后可以有所收获，话不多说，跟着小编一起来看看吧。

创新互联是一家专业提供翼城企业网站建设,专注与网站设计制作、成都网站制作、html5、小程序制作等业务。10年已为翼城众多企业、政府机构等服务。创新互联专业网站设计公司优惠进行中。

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{
  // 键
  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);
    }
  }
}

以上就是使用Java怎么实现本地缓存，小编相信有部分知识点可能是我们日常工作会见到或用到的。希望你能通过这篇文章学到更多知识。更多详情敬请关注创新互联行业资讯频道。

网页题目：使用Java怎么实现本地缓存
当前路径：http://chengdu.cdxwcx.cn/article/ipdpio.html