淺談本地緩存的幾種方案選型
一、摘要
說到緩存，面試官基本上會繞不開以下幾個話題！
項目中哪些地方用到了緩存？為什么要使用緩存？怎么使用它的？引入緩存后會帶來哪些問題？
這些問題，基本上是互聯網公司面試時必問的一些問題，如果面試的時候，連緩存都不清楚，那確實多少顯的有些尷尬！
項目里面為什么要引入緩存？這個問題還得結合項目中的業務來回答！
引入緩存，其實主要有兩個用途：高性能、高并發！
假設某個操作非常頻繁，比如網站的商城首頁，需要頻繁的從數據庫里面獲取商品數據，可能從數據庫一頓各種亂七八糟的操作下來，平均耗時 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 系列相關的技術實踐介紹。
本文參考了很多其他博主的文章，內容難免有描述不對的地方，歡迎網友留言指出！
