快取擊穿 解決方案

本文代碼邏輯思想來自阿里的JetCache框架，這里只是自己的學習與理解，記錄下；具體實作可以去查看JetCache原始碼：git地址：https://github.com/alibaba/jetcache
實際應用中可以接JetCache框架，使用@CachePenetrationProtect注解即可實作

當快取訪問未命中的情況下，對并發進行的加載行為進行保護， 當前版本實作的是單JVM內的保護，即同一個JVM中同一個key只有一個執行緒去加載，其它執行緒等待結果，

 1     // 本地快取map
 2     static Map<String, LoaderLock> loaderMap = new ConcurrentHashMap<>();
 3 
 4     static Object cachePenetrationProtectTest() {
 5 
 6         String redisKey = "redisKey";
 7 
 8         // TODO 查快取，查到則直接退出，沒查到則繼續往下執行，查詢資料庫
 9 　　　　　
　　　　　　
　　　　　　　// 原始碼中這里加了while(true),如果查詢資料庫操作拋例外(ll.isSuccess為false)，豈不是一直卡在回圈中了？
10         Object loadedValue;
11         // 用boolean陣列，而不是boolean變數，應該沒什么特別原因，主要是computeIfAbsent中的變數需要final修飾
12         boolean create[] = new boolean[1];
13         LoaderLock ll = loaderMap.computeIfAbsent(redisKey, key -> {
14             // 只有第一個請求進來時create[0]才會為true
15             create[0] = true;
16             LoaderLock loaderLock = new LoaderLock();
17             loaderLock.signal = new CountDownLatch(1);
18             return loaderLock;
19         });
20         // 是第一個進來的請求
21         if (create[0]) {
22             try {
23                 // TODO 執行具體業務代碼，這里loadedValue暫時回傳null(實際應該是業務代碼執行后的回傳值)
24                 loadedValue = https://www.cnblogs.com/dong320/p/null;
25                 // 這里存放執行業務代碼后需要回傳的值
26                 ll.value =https://www.cnblogs.com/dong320/p/ loadedValue;
27 
28                 // 業務代碼執行成功沒拋例外，則success修改為true
29                 ll.success = true;
30                 return loadedValue;
31             } finally {
32                 // 洗掉掉map中的lockKey值，使下個請求進來的時候create[0]可以為true
33                 loaderMap.remove(redisKey);
34                 // 讓其他執行緒結束等待
35                 ll.signal.countDown();
36             }
37         } else {
38             try {
39                 // 其他請求在這等待，設定個超時時間，可以做成可配
40                 ll.signal.await(5, TimeUnit.SECONDS);
41                 if (ll.success) {
42                     return ll.value;
43                 } else {
44                     // TODO 資料庫查詢例外，這里可以拋出例外，直接回傳請求，配合熔斷措施處理
45                     throw new RuntimeException("queryDB exception");
46                 }
47             } catch (InterruptedException e) {
48                 throw new CacheException("loader wait interrupted", e);
49             }
50         }
51     }
52 
53     static class LoaderLock {
54         CountDownLatch signal;
55         volatile boolean success;
56         volatile Object value;
57     }

JetCache部分原始碼(2.6.0版本)，synchronizedLoad方法：

static <K, V> V synchronizedLoad(CacheConfig config, AbstractCache<K,V> abstractCache,
                                     K key, Function<K, V> newLoader, Consumer<V> cacheUpdater) {
        ConcurrentHashMap<Object, LoaderLock> loaderMap = abstractCache.initOrGetLoaderMap();
        Object lockKey = buildLoaderLockKey(abstractCache, key);
        while (true) {
            boolean create[] = new boolean[1];
            LoaderLock ll = loaderMap.computeIfAbsent(lockKey, (unusedKey) -> {
                create[0] = true;
                LoaderLock loaderLock = new LoaderLock();
                loaderLock.signal = new CountDownLatch(1);
                loaderLock.loaderThread = Thread.currentThread();
                return loaderLock;
            });
            if (create[0] || ll.loaderThread == Thread.currentThread()) {
                try {
                    V loadedValue = newLoader.apply(key);
                    ll.success = true;
                    ll.value = loadedValue;
                    cacheUpdater.accept(loadedValue);
                    return loadedValue;
                } finally {
                    if (create[0]) {
                        ll.signal.countDown();
                        loaderMap.remove(lockKey);
                    }
                }
            } else {
                try {
                    Duration timeout = config.getPenetrationProtectTimeout();
                    if (timeout == null) {
                        ll.signal.await();
                    } else {
                        boolean ok = ll.signal.await(timeout.toMillis(), TimeUnit.MILLISECONDS);
                        if(!ok) {
                            logger.info("loader wait timeout:" + timeout);
                            return newLoader.apply(key);
                        }
                    }
                } catch (InterruptedException e) {
                    logger.warn("loader wait interrupted");
                    return newLoader.apply(key);
                }
                if (ll.success) {
                    return (V) ll.value;
                } else {
                    continue;
                }

            }
        }
    }

static class LoaderLock {
        CountDownLatch signal;
        Thread loaderThread;
        volatile boolean success;
        volatile Object value;
    }

標籤：Java

上一篇：Web服務器之Nginx

下一篇：多執行緒筆記