實現 Java 本地緩存，該從這幾點開始

時間 2019-11-22

標籤實現 java 本地緩存從這幾點開始欄目 Java 简体版

原文原文鏈接

緩存，我相信你們對它必定不陌生，在項目中，緩存確定是必不可少的。市面上有很是多的緩存工具，好比 Redis、Guava Cache 或者 EHcache。對於這些工具，我想你們確定都很是熟悉，因此今天咱們不聊它們，咱們來聊一聊如何實現本地緩存。參考上面幾種工具，要實現一個較好的本地緩存，平頭哥認爲要從如下三個方面開始。java

一、存儲集合的選擇

實現本地緩存，存儲容器確定是 key/value 形式的數據結構，在 Java 中，也就是咱們經常使用的 Map 集合。Map 中有 HashMap、Hashtable、ConcurrentHashMap 幾種供咱們選擇，若是不考慮高併發狀況下數據安全問題，咱們能夠選擇HashMap，若是考慮高併發狀況下數據安全問題，咱們能夠選擇 Hashtable、ConcurrentHashMap 中的一種集合，可是咱們優先選擇 ConcurrentHashMap，由於 ConcurrentHashMap 的性能比 Hashtable 要好。git

二、過時緩存處理

由於緩存直接存儲在內存中，若是咱們不處理過時緩存，內存將被大量無效緩存佔用，這不是咱們想要的，因此咱們須要清理這些失效的緩存。過時緩存處理能夠參考 Redis 的策略來實現，Redis 採用的是按期刪除 + 懶惰淘汰策略。github

按期刪除策略

按期刪除策略是每隔一段時間檢測已過時的緩存，而且降之刪除。這個策略的優勢是可以確保過時的緩存都會被刪除。同時也存在着缺點，過時的緩存不必定可以及時的被刪除，這跟咱們設置的定時頻率有關係，另外一個缺點是若是緩存數據較多時，每次檢測也會給 cup 帶來不小的壓力。緩存

懶惰淘汰策略

懶惰淘汰策略是在使用緩存時，先判斷緩存是否過時，若是過時將它刪除，而且返回空。這個策略的優勢是隻有在查找的時候，才判斷是否過時，對 CUP 影響較。同時這種策略有致命的缺點，當存入了大量的緩存，這些緩存都沒有被使用而且已過時，都將成爲無效緩存，這些無效的緩存將佔用你大量的內存空間，最後致使服務器內存溢出。安全

咱們簡單的瞭解了一下 Redis 的兩種過時緩存處理策略，每種策略都存在本身的優缺點。因此咱們在使用過程當中，能夠將兩種策略組合起來，結合效果仍是很是理想的。服務器

三、緩存淘汰策略

緩存淘汰跟過時緩存處理要區別開來，緩存淘汰是指當咱們的緩存個數達到咱們指定的緩存個數時，畢竟咱們的內存不是無限的。若是咱們須要繼續添加緩存的話，咱們就須要在現有的緩存中根據某種策略淘汰一些緩存，給新添加的緩存騰出位置，下面一塊兒來認識幾種經常使用的緩存淘汰策略。微信

先進先出策略

最早進入緩存的數據在緩存空間不夠的狀況下會被優先被清除掉，以騰出新的空間接受新的數據。該策略主要比較緩存元素的建立時間。在一些對數據實效性要求比較高的場景下，可考慮選擇該類策略，優先保障最新數據可用。數據結構

最少使用策略

不管是否過時，根據元素的被使用次數判斷，清除使用次數較少的元素釋放空間。該策略主要比較元素的hitCount（命中次數），在保證高頻數據有效性場景下，可選擇這類策略。併發

隨機淘汰策略

不管是否過時，隨機淘汰某個緩存，若是對緩存數據沒有任何要求，能夠考慮使用該策略。

不淘汰策略

當緩存達到指定值以後，不淘汰任何緩存，而是不能新增緩存，直到有緩存淘汰時，才能繼續添加緩存。

上面是實現本地緩存須要考慮的三個點，看完咱們應該知該如何實現一個本地緩存了，不妨咱們一塊兒來實現一個本地緩存。

實現本地緩存

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