3种堆内缓存算法,赠源码和设计思路

存储 存储软件 算法
要说计算机系统里,什么技术把tradeoff体现的淋漓尽致,那肯定是缓存无疑。为了协调高速部件和低速部件的速度差异,加入一个中间缓存层,是解决这种冲突最有效的方案。

 要说计算机系统里,什么技术把tradeoff体现的淋漓尽致,那肯定是缓存无疑。为了协调高速部件和低速部件的速度差异,加入一个中间缓存层,是解决这种冲突最有效的方案。

[[325756]]

其中,JVM堆内缓存是缓存体系中重要的一环,最常用的有FIFO/LRU/LFU三种算法。

  1. FIFO是简单的队列,先进先出。
  2. LRU是最近最少使用,优先移除最久未使用的数据。是时间维度。
  3. LFU是最近最不常用,优先移除访问次数最少的数据。是统计维度。

由于过期也是缓存的一个重要特点。所有在设计这三种缓存算法时,需要额外的存储空间去存储这个过期时间。

以下将讨论这三种缓存算法的操作和设计要点,但暂未考虑高并发环境。

FIFO

先进先出,如果缓存容量满,则优先移出最早加入缓存的数据;其内部可以使用队列实现。

操作

  • Object get(key) :获取保存的数据,如果数据不存在或者已经过期,则返回null。
  • void put(key,value,expireTime):加入缓存。 无论此key是否已存在,均作为新key处理(移除旧key);如果空间不足,则移除已过期的key,如果没有,则移除最早加入缓存的key。过期时间未指定,则表示永不自动过期。
  • 注意 ,我们允许key是有过期时间的,这一点与普通的FIFO有所区别,所以在设计此题时需要注意。(也是面试考察点,偏设计而非算法)

普通的FIFO或许大家都能很简单的写出,增加了过期时间的考虑之后,在设计时需要多考虑。如下示例,为暂未考虑并发环境的FIFO设计。

设计思路

1)用普通的hashMap保存缓存数据。

2)需要额外的map用来保存key的过期特性,例子中使用了TreeMap,将“剩余存活时间”作为key,利用TreeMap的排序特性。

  1. public class FIFOCache { 
  2.    
  3.     //按照访问时间排序,保存所有key-value 
  4.     private final Map<String,Value> CACHE = new LinkedHashMap<>(); 
  5.    
  6.     //过期数据,只保存有过期时间的key 
  7.     //暂不考虑并发,我们认为同一个时间内没有重复的key,如果改造的话,可以将value换成set 
  8.     private final TreeMap<Long, String> EXPIRED = new TreeMap<>(); 
  9.    
  10.     private final int capacity; 
  11.    
  12.     public FIFOCache(int capacity) { 
  13.         this.capacity = capacity; 
  14.     } 
  15.    
  16.     public Object get(String key) { 
  17.         // 
  18.         Value value = CACHE.get(key); 
  19.         if (value == null) { 
  20.             return null
  21.         } 
  22.    
  23.         //如果不包含过期时间 
  24.         long expired = value.expired; 
  25.         long now = System.nanoTime(); 
  26.         //已过期 
  27.         if (expired > 0 && expired <= now) { 
  28.             CACHE.remove(key); 
  29.             EXPIRED.remove(expired); 
  30.             return null
  31.         } 
  32.         return value.value; 
  33.     } 
  34.    
  35.     public void put(String key,Object value) { 
  36.         put(key,value,-1); 
  37.     } 
  38.    
  39.    
  40.     public void put(String key,Object value,int seconds) { 
  41.         //如果容量不足,移除过期数据 
  42.         if (capacity < CACHE.size()) { 
  43.             long now = System.nanoTime(); 
  44.             //有过期的,全部移除 
  45.             Iterator<Long> iterator = EXPIRED.keySet().iterator(); 
  46.             while (iterator.hasNext()) { 
  47.                 long _key = iterator.next(); 
  48.                 //如果已过期,或者容量仍然溢出,则删除 
  49.                 if (_key > now) { 
  50.                     break; 
  51.                 } 
  52.                 //一次移除所有过期key 
  53.                 String _value = EXPIRED.get(_key); 
  54.                 CACHE.remove(_value); 
  55.                 iterator.remove(); 
  56.             } 
  57.         } 
  58.    
  59.         //如果仍然容量不足,则移除最早访问的数据 
  60.         if (capacity < CACHE.size()) { 
  61.             Iterator<String> iterator = CACHE.keySet().iterator(); 
  62.             while (iterator.hasNext() && capacity < CACHE.size()) { 
  63.                 String _key = iterator.next(); 
  64.                 Value _value = CACHE.get(_key); 
  65.                 long expired = _value.expired; 
  66.                 if (expired > 0) { 
  67.                     EXPIRED.remove(expired); 
  68.                 } 
  69.                 iterator.remove(); 
  70.             } 
  71.         } 
  72.    
  73.         //如果此key已存在,移除旧数据 
  74.         Value current = CACHE.remove(key); 
  75.         if (current != null && current.expired > 0) { 
  76.             EXPIRED.remove(current.expired); 
  77.         } 
  78.         //如果指定了过期时间 
  79.         if(seconds > 0) { 
  80.             long expireTime = expiredTime(seconds); 
  81.             EXPIRED.put(expireTime,key); 
  82.             CACHE.put(key,new Value(expireTime,value)); 
  83.         } else { 
  84.             CACHE.put(key,new Value(-1,value)); 
  85.         } 
  86.    
  87.     } 
  88.    
  89.     private long expiredTime(int expired) { 
  90.         return System.nanoTime() + TimeUnit.SECONDS.toNanos(expired); 
  91.     } 
  92.    
  93.     public void remove(String key) { 
  94.         Value value = CACHE.remove(key); 
  95.         if(value == null) { 
  96.             return
  97.         } 
  98.         long expired = value.expired; 
  99.         if (expired > 0) { 
  100.             EXPIRED.remove(expired); 
  101.         } 
  102.     } 
  103.    
  104.    
  105.     class Value { 
  106.         long expired; //过期时间,纳秒 
  107.         Object value; 
  108.         Value(long expired,Object value) { 
  109.             this.expired = expired; 
  110.             this.value = value; 
  111.         } 
  112.     } 

LRU

least recently used,最近最少使用,是目前最常用的缓存算法和设计方案之一,其移除策略为“当缓存(页)满时,优先移除最近最久未使用的数据”,优点是易于设计和使用,适用场景广泛。算法可以参考leetcode 146 (LRU Cache)。

操作

  • Object get(key):从cache中获取key对应的数据,如果此key已过期,移除此key,并则返回null。
  • void put(key,value,expired):设置k-v,如果容量不足,则根据LRU置换算法移除“最久未被使用的key”。 需要注意,根据LRU优先移除已过期的keys,如果没有,则根据LRU移除未过期的key。如果未设定过期时间,则认为永不自动过期。
  • 这里的设计关键是过期时间特性,这与常规的LRU有所不同。

设计思路

  • LRU的基础算法,需要了解;每次put、get时需要更新key对应的访问时间,我们需要一个数据结构能够保存key最近的访问时间且能够排序。
  • 既然包含过期时间特性,那么带有过期时间的key需要额外的数据结构保存。
  • 暂时不考虑并发操作;尽量兼顾空间复杂度和时间复杂度。
  • 此题仍然偏向于设计题,而非纯粹的算法题。

此题代码与FIFO基本相同,唯一不同点为get()方法,对于LRU而言,get方法需要重设访问时间(即调整所在cache中顺序)

  1. public Object get(String key) { 
  2.     // 
  3.     Value value = CACHE.get(key); 
  4.     if (value == null) { 
  5.         return null
  6.     } 
  7.    
  8.     //如果不包含过期时间 
  9.     long expired = value.expired; 
  10.     long now = System.nanoTime(); 
  11.     //已过期 
  12.     if (expired > 0 && expired <= now) { 
  13.         CACHE.remove(key); 
  14.         EXPIRED.remove(expired); 
  15.         return null
  16.     } 
  17.     //相对于FIFO,增加顺序重置 
  18.     CACHE.remove(key); 
  19.     CACHE.put(key,value); 
  20.     return value.value; 

LFU

最近最不常用,当缓存容量满时,移除 访问次数 最少的元素,如果访问次数相同的元素有多个,则移除最久访问的那个。设计要求参见leetcode 460( LFU Cache)

  1. public class LFUCache { 
  2.    
  3.     //主要容器,用于保存k-v 
  4.     private Map<String, Object> keyToValue = new HashMap<>(); 
  5.    
  6.     //记录每个k被访问的次数 
  7.     private Map<String, Integer> keyToCount = new HashMap<>(); 
  8.    
  9.     //访问相同次数的key列表,按照访问次数排序,value为相同访问次数到key列表。 
  10.     private TreeMap<Integer, LinkedHashSet<String>> countToLRUKeys = new TreeMap<>(); 
  11.    
  12.     private int capacity; 
  13.    
  14.     public LFUCache(int capacity) { 
  15.         this.capacity = capacity; 
  16.         //初始化,默认访问1次,主要是解决下文 
  17.     } 
  18.    
  19.     public Object get(String key) { 
  20.         if (!keyToValue.containsKey(key)) { 
  21.             return null
  22.         } 
  23.    
  24.         touch(key); 
  25.         return keyToValue.get(key); 
  26.     } 
  27.    
  28.     /** 
  29.      * 如果一个key被访问,应该将其访问次数调整。 
  30.      * @param key 
  31.      */   
  32.     private void touch(String key) { 
  33.         int count = keyToCount.get(key); 
  34.         keyToCount.put(keycount + 1);//访问次数增加 
  35.         //从原有访问次数统计列表中移除 
  36.         countToLRUKeys.get(count).remove(key); 
  37.    
  38.         //如果符合最少调用次数到key统计列表为空,则移除此调用次数到统计 
  39.         if (countToLRUKeys.get(count).size() == 0) { 
  40.             countToLRUKeys.remove(count); 
  41.         } 
  42.    
  43.         //然后将此key的统计信息加入到管理列表中 
  44.         LinkedHashSet<String> countKeys = countToLRUKeys.get(count + 1); 
  45.         if (countKeys == null) { 
  46.             countKeys = new LinkedHashSet<>(); 
  47.             countToLRUKeys.put(count + 1,countKeys); 
  48.         } 
  49.         countKeys.add(key); 
  50.     } 
  51.    
  52.     public void put(String key, Object value) { 
  53.         if (capacity <= 0) { 
  54.             return
  55.         } 
  56.    
  57.         if (keyToValue.containsKey(key)) { 
  58.             keyToValue.put(key, value); 
  59.             touch(key); 
  60.             return
  61.         } 
  62.         //容量超额之后,移除访问次数最少的元素 
  63.         if (keyToValue.size() >= capacity) { 
  64.             Map.Entry<Integer,LinkedHashSet<String>> entry = countToLRUKeys.firstEntry(); 
  65.             Iterator<String> it = entry.getValue().iterator(); 
  66.             String evictKey = it.next(); 
  67.             it.remove(); 
  68.             if (!it.hasNext()) { 
  69.                 countToLRUKeys.remove(entry.getKey()); 
  70.             } 
  71.             keyToCount.remove(evictKey); 
  72.             keyToValue.remove(evictKey); 
  73.    
  74.         } 
  75.    
  76.         keyToValue.put(key, value); 
  77.         keyToCount.put(key, 1); 
  78.         LinkedHashSet<String> keys = countToLRUKeys.get(1); 
  79.         if (keys == null) { 
  80.             keys = new LinkedHashSet<>(); 
  81.             countToLRUKeys.put(1,keys); 
  82.         } 
  83.         keys.add(key); 
  84.     } 

End本文力求比较三个基本的缓存算法,以便对缓存建设之路有一个比较笼统的感觉。

更加易用的cache,可以参考guava的实现。谨希望这三个代码模版,能够对你有所帮助。

作者简介:小姐姐味道 (xjjdog),一个不允许程序员走弯路的公众号。聚焦基础架构和Linux。十年架构,日百亿流量,与你探讨高并发世界,给你不一样的味道。

责任编辑:武晓燕 来源: 小姐姐味道
相关推荐

2023-09-17 23:16:46

缓存数据库

2021-07-11 18:06:18

缓存过期淘汰

2022-08-28 16:31:11

缓存雪崩

2016-02-18 10:09:23

12306核心思路架构

2021-11-08 11:21:18

redis 淘汰算法

2012-12-17 14:54:55

算法缓存Java

2011-12-06 09:24:10

网页设计

2018-06-26 15:58:39

进程内缓存缓存数据

2021-10-08 11:45:33

内存HeapByteBuf堆内

2022-04-04 16:53:56

Vue.js设计框架

2023-12-03 21:52:20

2022-09-06 15:30:20

缓存一致性

2017-04-10 08:14:28

移动应用应用内搜索业务转化

2021-11-30 10:58:52

算法缓存技术

2009-06-15 14:15:07

Java设计模式Java

2022-08-17 09:07:09

低代码LCDP编码

2009-08-14 17:28:14

多表单系统

2020-11-23 08:53:34

堆Heap

2021-10-12 08:34:23

React组件前端

2014-03-17 10:30:12

网络服务器
点赞
收藏

51CTO技术栈公众号