一、摘要

說到緩存，面試官基本上會繞不開以下幾個話題！

項目中哪些地方用到了緩存？為什么要使用緩存？怎么使用它的？引入緩存后會帶來哪些問題？

這些問題，基本上是互聯網公司面試時必問的一些問題，如果面試的時候，連緩存都不清楚，那確實多少顯的有些尷尬！

項目里面為什么要引入緩存？這個問題還得結合項目中的業務來回答！

引入緩存，其實主要有兩個用途： 高性能 、 高并發 ！

假設某個操作非常頻繁，比如網站的商城首頁，需要頻繁的從數據庫里面獲取商品數據，可能從數據庫一頓各種亂七八糟的操作下來，平均耗時 500 ms，隨著請求頻次越高，用戶等待數據的返回結果時間越來越長，體驗越來越差。

如果此時， 引入緩存 ，將數據庫里面查詢出來的商品數據信息，放入緩存服務里面，當用戶再此發起查詢操作的時候，直接從緩存服務里面獲取，速度從耗時 500 ms，可能直接優化成 5 ms，體驗上瞬間會上升好幾個層次！

這就是引入緩存帶來的高性能體驗結果 ！

當然，除此之外， 引入緩存之前 ，以 mysql 數據庫為例，單臺機器一秒內的請求次數到達 2000 之后就會開始報警； 引入緩存之后 ，比如以 redis 緩存服務器為例，單臺機器一秒內的請求次數支持 110000 次，兩者支持的并發量完全不是一個數量級的。

這就是引入緩存帶來的高并發體驗結果 ！

尤其是對于流量很大的業務，引入緩存，給系統帶來的提升是十分顯著的 。

可能有的同學又會發出疑問，緩存和數據庫為啥差距這么大，有啥區別？

我們都知道在計算機領域，數據的存儲主要有兩處： 一處是內存，另一處是磁盤 。

在計算機中，內存的數據讀寫性能遠超磁盤的讀寫性能，盡管如此，其實兩者也有不同，如果數據存儲到內存中，雖然讀寫性能非常高，但是當電腦重啟之后，數據會全部清除；而存入磁盤的數據，雖然讀寫性能很差，但是電腦重啟之后數據不會丟失。

因為兩者的數據存儲方案不同，造就了不同的實踐用途 ！

我們上面講到的緩存服務，其實本質就是將數據存儲到內存中；而數據庫服務，是將數據寫入到磁盤，從磁盤中讀取數據。

無論是哪種方案，沒有絕對的好與壞，主要還是取決于實際的業務用途。

在項目中如何引入緩存呢？我們通常的做法如下：

操作步驟：

• 1.當用戶發起訪問某數據的操作時，檢查緩存服務里面是否存在，如果存在，直接返回；如果不存在，走數據庫的查詢服務
• 2.從數據庫里面獲取到有效數據之后，存入緩存服務，并返回給用戶
• 3.當被訪問的數據發生更新的時候，需要同時刪除緩存服務，以便用戶再次查詢的時候，能獲取到最新的數據

當然以上的緩存處理辦法，對于簡單的需要緩存的業務場景，能輕松應對。

但是面對復雜的業務場景和服務架構，尤其是對緩存要求比較高的業務，引入緩存的方式，也會跟著一起變化！

從緩存面向的對象不同，緩存分為： 本地緩存 、分布式緩存和 多級緩存 。

所謂 本地緩存 ，相信大家都能理解，在單個計算機服務實例中，直接把數據緩存到內存中進行使用。

但是現在的服務，大多都是以集群的方式來部署，你也可以這樣理解，同一個網站服務，同時在兩臺計算機里面部署，比如你用到的session會話，就無法同時共享，因此需要引入一個獨立的緩存服務來連接兩臺服務器，這個獨立部署的緩存服務，我們把這種技術實踐方案稱為 分布式緩存 。

在實際的業務中，本地緩存和分布式緩存會同時結合進行使用，當收到訪問某個數據的操作時，會優先從本地緩存服務（也叫一級緩存）查詢，如果沒有，再從分布式緩存服務（也叫二級緩存）里面獲取，如果也沒有，最后再從數據庫里面獲取；從數據庫查詢完成之后，在依次更新分布式緩存服務、本次緩存服務，我們把這個技術實踐方案叫 多級緩存 ！

由于篇幅的原因，我們在后期給大家介紹 分布式緩存服務 、 多級緩存服務 。

今天主要圍繞本地緩存服務的技術實現，給大家進行分享和介紹！

二、方案介紹

如果使用過緩存的同學，可以很容易想到緩存需要哪些東西，通常我們在使用緩存的時候，比較關注兩個地方，第一是內存持久化，第二是支持緩存的數據自動過期清楚。

基于以上的要求，我們向介紹以下幾種技術實現方案。

2.1、手寫一個緩存服務

對于簡單的數據緩存，我們完全可以自行編寫一套緩存服務，實現過程如下！

首先創建一個緩存實體類

public class CacheEntity {

    /**
     * 緩存鍵
     */
    private String key;

    /**
     * 緩存值
     */
    private Object value;

    /**
     * 過期時間
     */
    private Long expireTime;

    //...set、get
}

接著，編寫一個緩存操作工具類CacheUtils

public class CacheUtils {

    /**
     * 緩存數據
     */
    private final static Map< String, CacheEntity > CACHE_MAP = new ConcurrentHashMap<  >();

    /**
     * 定時器線程池，用于清除過期緩存
     */
    private static ScheduledExecutorService executor = Executors.newSingleThreadScheduledExecutor();


    static {
        // 注冊一個定時線程任務，服務啟動1秒之后，每隔500毫秒執行一次
        executor.scheduleAtFixedRate(new Runnable() {
            @Override
            public void run() {
                // 清理過期緩存
                clearCache();
            }
        },1000,500,TimeUnit.MILLISECONDS);
    }

    /**
     * 添加緩存
     * @param key    緩存鍵
     * @param value  緩存值
     */
    public static void put(String key, Object value){
        put(key, value, 0);
    }


    /**
     * 添加緩存
     * @param key    緩存鍵
     * @param value  緩存值
     * @param expire 緩存時間，單位秒
     */
    public static void put(String key, Object value, long expire){
        CacheEntity cacheEntity = new CacheEntity()
                .setKey(key)
                .setValue(value);
        if(expire > 0){
            Long expireTime = System.currentTimeMillis() + Duration.ofSeconds(expire).toMillis();
            cacheEntity.setExpireTime(expireTime);
        }
        CACHE_MAP.put(key, cacheEntity);
    }


    /**
     * 獲取緩存
     * @param key
     * @return
     */
    public static Object get(String key){
        if(CACHE_MAP.containsKey(key)){
            return CACHE_MAP.get(key).getValue();
        }
        return null;
    }

    /**
     * 移除緩存
     * @param key
     */
    public static void remove(String key){
        if(CACHE_MAP.containsKey(key)){
            CACHE_MAP.remove(key);
        }
    }

    /**
     * 清理過期的緩存數據
     */
    private static void clearCache(){
        if(CACHE_MAP.size() > 0){
            return;
        }
        Iterator< Map.Entry< String, CacheEntity >> iterator = CACHE_MAP.entrySet().iterator();
        while (iterator.hasNext()){
            Map.Entry< String, CacheEntity > entry = iterator.next();
            if(entry.getValue().getExpireTime() != null && entry.getValue().getExpireTime().longValue() > System.currentTimeMillis()){
                iterator.remove();
            }
        }
    }

}

最后，我們來測試一下緩存服務

// 寫入緩存數據
CacheUtils.put("userName", "張三", 3);

// 讀取緩存數據
Object value1 = CacheUtils.get("userName");
System.out.println("第一次查詢結果：" + value1);

// 停頓4秒
Thread.sleep(4000);

// 讀取緩存數據
Object value2 = CacheUtils.get("userName");
System.out.println("第二次查詢結果：" + value2);

輸出結果，與預期一致！

第一次查詢結果：張三
第二次查詢結果：null

實現思路其實很簡單，采用ConcurrentHashMap作為緩存數據存儲服務，然后開啟一個定時調度，每隔500毫秒檢查一下過期的緩存數據，然后清除掉！

2.2、基于 Guava Cache 實現本地緩存

Guava 是 Google 團隊開源的一款 Java 核心增強庫，包含集合、并發原語、緩存、IO、反射等工具箱，性能和穩定性上都有保障，應用十分廣泛。

相比自己編寫的緩存服務，Guava Cache 要強大的多，支持很多特性如下：

• 支持最大容量限制
• 支持兩種過期刪除策略（插入時間和讀取時間）
• 支持簡單的統計功能
• 基于 LRU 算法實現

使用方面也很簡單，首先引入guava庫包。

< !--guava-- >
< dependency >
    < groupId >com.google.guava< /groupId >
    < artifactId >guava< /artifactId >
    < version >31.1-jre< /version >
< /dependency >

案例代碼如下：

// 創建一個緩存實例
Cache< String, String > cache = CacheBuilder.newBuilder()
        // 初始容量
        .initialCapacity(5)
        // 最大緩存數，超出淘汰
        .maximumSize(10)
        // 過期時間
        .expireAfterWrite(3, TimeUnit.SECONDS)
        .build();

// 寫入緩存數據
cache.put("userName", "張三");

// 讀取緩存數據
String value1 = cache.get("userName", () - > {
    // 如果key不存在，會執行回調方法
    return "key已過期";
});
System.out.println("第一次查詢結果：" + value1);

// 停頓4秒
Thread.sleep(4000);

// 讀取緩存數據
String value2 = cache.get("userName", () - > {
    // 如果key不存在，會執行回調方法
    return "key已過期";
});
System.out.println("第二次查詢結果：" + value2);

輸出結果：

第一次查詢結果：張三
第二次查詢結果：key已過期

2.3、基于 Caffeine 實現本地緩存

Caffeine 是基于 java8 實現的新一代緩存工具，緩存性能接近理論最優，可以看作是 Guava Cache 的增強版，功能上兩者類似，不同的是 Caffeine 采用了一種結合 LRU、LFU 優點的算法：W-TinyLFU，在性能上有明顯的優越性。

使用方面也很簡單，首先引入caffeine庫包。

< !--caffeine-- >
< dependency >
    < groupId >com.github.ben-manes.caffeine< /groupId >
    < artifactId >caffeine< /artifactId >
    < version >2.9.3< /version >
< /dependency >

案例代碼如下：

// 創建一個緩存實例
Cache< String, String > cache = Caffeine.newBuilder()
        // 初始容量
        .initialCapacity(5)
        // 最大緩存數，超出淘汰
        .maximumSize(10)
        // 設置緩存寫入間隔多久過期
        .expireAfterWrite(3, TimeUnit.SECONDS)
        // 設置緩存最后訪問后間隔多久淘汰，實際很少用到
        //.expireAfterAccess(3, TimeUnit.SECONDS)
        .build();

// 寫入緩存數據
cache.put("userName", "張三");

// 讀取緩存數據
String value1 = cache.get("userName", (key) - > {
    // 如果key不存在，會執行回調方法
    return "key已過期";
});
System.out.println("第一次查詢結果：" + value1);

// 停頓4秒
Thread.sleep(4000);

// 讀取緩存數據
String value2 = cache.get("userName", (key) - > {
    // 如果key不存在，會執行回調方法
    return "key已過期";
});
System.out.println("第二次查詢結果：" + value2);

輸出結果：

第一次查詢結果：張三
第二次查詢結果：key已過期

2.4、基于 Encache 實現本地緩存

Encache 是一個純 Java 的進程內緩存框架，具有快速、精干等特點，是 Hibernate 中默認的 CacheProvider。

同 Caffeine 和 Guava Cache 相比，Encache 的功能更加豐富，擴展性更強，特性如下：

• 支持多種緩存淘汰算法，包括 LRU、LFU 和 FIFO
• 緩存支持堆內存儲、堆外存儲、磁盤存儲（支持持久化）三種
• 支持多種集群方案，解決數據共享問題

使用方面也很簡單，首先引入ehcache庫包。

< !--ehcache-- >
< dependency >
    < groupId >org.ehcache< /groupId >
    < artifactId >ehcache< /artifactId >
    < version >3.9.7< /version >
< /dependency >

案例代碼如下：

/**
 * 自定義過期策略實現
 */
public  class CustomExpiryPolicy< K, V > implements ExpiryPolicy< K, V > {

    private final Map< K, Duration > keyExpireMap = new ConcurrentHashMap();


    public Duration setExpire(K key, Duration duration) {
        return keyExpireMap.put(key, duration);
    }

    public Duration getExpireByKey(K key) {
        return Optional.ofNullable(keyExpireMap.get(key))
                .orElse(null);
    }

    public Duration removeExpire(K key) {
        return keyExpireMap.remove(key);
    }

    @Override
    public Duration getExpiryForCreation(K key, V value) {
        return Optional.ofNullable(getExpireByKey(key))
                .orElse(Duration.ofNanos(Long.MAX_VALUE));
    }

    @Override
    public Duration getExpiryForAccess(K key, Supplier< ? extends V > value) {
        return getExpireByKey(key);
    }

    @Override
    public Duration getExpiryForUpdate(K key, Supplier< ? extends V > oldValue, V newValue) {
        return getExpireByKey(key);
    }
}

public static void main(String[] args) throws InterruptedException {
    String userCache = "userCache";

    // 自定義過期策略
    CustomExpiryPolicy< Object, Object > customExpiryPolicy = new CustomExpiryPolicy<  >();

    // 聲明一個容量為20的堆內緩存配置
    CacheConfigurationBuilder configurationBuilder = CacheConfigurationBuilder
            .newCacheConfigurationBuilder(String.class, String.class, ResourcePoolsBuilder.heap(20))
            .withExpiry(customExpiryPolicy);

    // 初始化一個緩存管理器
    CacheManager cacheManager = CacheManagerBuilder.newCacheManagerBuilder()
            // 創建cache實例
            .withCache(userCache, configurationBuilder)
            .build(true);

    // 獲取cache實例
    Cache< String, String > cache = cacheManager.getCache(userCache, String.class, String.class);
    // 獲取過期策略
    CustomExpiryPolicy expiryPolicy = (CustomExpiryPolicy)cache.getRuntimeConfiguration().getExpiryPolicy();

    // 寫入緩存數據
    cache.put("userName", "張三");
    // 設置3秒過期
    expiryPolicy.setExpire("userName", Duration.ofSeconds(3));

    // 讀取緩存數據
    String value1 = cache.get("userName");
    System.out.println("第一次查詢結果：" + value1);

    // 停頓4秒
    Thread.sleep(4000);

    // 讀取緩存數據
    String value2 = cache.get("userName");
    System.out.println("第二次查詢結果：" + value2);
}

輸出結果：

第一次查詢結果：張三
第二次查詢結果：null

三、小結

從易用性角度看：Guava Cache、Caffeine 和 Encache 都有十分成熟的接入方案，使用簡單。

從功能性角度看：Guava Cache 和 Caffeine 功能類似，都是只支持堆內緩存，Encache 相比功能更為豐富，不僅支持堆內緩存，還支持磁盤寫入、集群實現。

從性能角度看：Caffeine 最優、GuavaCache 次之，Encache 最差。

以下是網絡上三者性能對比的結果。

對于本地緩存的技術選型， 推薦采用 Caffeine ，性能上毫無疑問，遙遙領先。

雖然 Encache 功能非常的豐富，甚至提供了持久化和集群的功能，但是相比更成熟的分布式緩存中間件 redis 來說，還是稍遜一些！

關于 redis 的使用，有興趣的同學可以查看歷史文章，之前有寫過 redis 系列相關的技術實踐介紹。