實現 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或者其他緩存工具，它們在實現原理上，跟我們本地緩存的實現原理都差不多。只要我們理解了本地緩存的實現原理，在去學習這些緩存工具，我相信還是會比較輕鬆的。