LRU缓存替换策略

缓存是一种非常常见的设计，通过将数据缓存到访问速度更快的存储设备中，来提高数据的访问速度，如内存、CPU缓存、硬盘缓存等。

但与缓存的高速相对的是，缓存的成本较高，因此容量往往是有限的，当缓存满了之后，就需要一种策略来决定将哪些数据移除出缓存，以腾出空间来存储新的数据。

这样的策略被称为缓存替换策略（Cache Replacement Policy）。

常见的缓存替换策略有：FIFO（First In First Out）、LRU（Least Recently Used）、LFU（Least Frequently Used）等。

今天给大家介绍的是LRU算法。

核心思想

LRU算法基于这样一个假设：如果数据最近被访问过，那么将来被访问的几率也更高。

大部分情况下这个假设是成立的，因此LRU算法也是比较常用的缓存替换策略。

基于这个假设，我们在实现的时候，需要维护一个有序的数据结构，来记录数据的访问历史，当缓存满了之后，就可以根据这个数据结构来决定将哪些数据移除出缓存。

不适用场景

但如果数据的访问模式不符合LRU算法的假设，那么LRU算法就会失效。

例如：数据的访问模式是周期性的，那么LRU算法就会把周期性的数据淘汰掉，这样就会导致缓存命中率的下降。

换个说法比如，如果现在缓存的数据只在白天被访问，晚上访问的是另一批数据，那么在晚上，LRU算法就会把白天访问的数据淘汰掉，第二天白天又会把昨天晚上访问的数据淘汰掉，这样就会导致缓存命中率的下降。

后面有时间会给大家介绍LFU（Least Frequently Used）算法，以及LFU和LRU的结合LFRU（Least Frequently and Recently Used）算法，可以有效的解决这个问题。

算法基本实现

上文提到，LRU算法需要维护一个有序的数据结构，来记录数据的访问历史。通常我们会用双向链表来实现这个数据结构，因为双向链表可以在O(1)的时间复杂度内往链表的头部或者尾部插入数据，以及在O(1)的时间复杂度内删除数据。

我们将数据存储在双向链表中，每次访问数据的时候，就将数据移动到链表的尾部，这样就可以保证链表的尾部就是最近访问的数据，链表的头部就是最久没有被访问的数据。

当缓存满了之后，如果需要插入新的数据，因为链表的头部就是最久没有被访问的数据，所以我们就可以直接将链表的头部删除，然后将新的数据插入到链表的尾部。

如果我们要实现一个键值对的缓存，我们可以用一个哈希表来存储键值对，这样就可以在O(1)的时间复杂度内完成查找操作，.NET 中我们可以使用 Dictionary。

同时我们使用 LinkedList 来作为双向链表的实现，存储缓存的 key，以此记录数据的访问历史。

我们在每次操作 Dictionary 进行插入、删除、查找的时候，都需要将对应的 key 也插入、删除、移动到链表的尾部。

  1. // 实现 IEnumerable 接口，方便遍历
  2. public class LRUCache<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
  3. {
  4.     private readonly LinkedList<TKey> _list;
  6.     private readonly Dictionary<TKey, TValue> _dictionary;
  8.     private readonly int _capacity;
  10.     public LRUCache(int capacity)
  11.     {
  12.         _capacity = capacity;
  13.         _list = new LinkedList<TKey>();
  14.         _dictionary = new Dictionary<TKey, TValue>();
  15.     }
  17.     public TValue Get(TKey key)
  18.     {
  19.         if (_dictionary.TryGetValue(key, out var value))
  20.         {
  21.             // 在链表中删除 key，然后将 key 添加到链表的尾部
  22.             // 这样就可以保证链表的尾部就是最近访问的数据，链表的头部就是最久没有被访问的数据
  23.             // 但是在链表中删除 key 的时间复杂度是 O(n)，所以这个算法的时间复杂度是 O(n)
  24.             _list.Remove(key);
  25.             _list.AddLast(key);
  26.             return value;
  27.         }
  29.         return default;
  30.     }
  32.     public void Put(TKey key, TValue value)
  33.     {
  34.         if (_dictionary.TryGetValue(key, out _))
  35.         {
  36.             // 如果插入的 key 已经存在，将 key 对应的值更新，然后将 key 移动到链表的尾部
  37.             _dictionary[key] = value;
  38.             _list.Remove(key);
  39.             _list.AddLast(key);
  40.         }
  41.         else
  42.         {
  43.             if (_list.Count == _capacity)
  44.             {
  45.                 // 缓存满了，删除链表的头部，也就是最久没有被访问的数据
  46.                 _dictionary.Remove(_list.First.Value);
  47.                 _list.RemoveFirst();
  48.             }
  50.             _list.AddLast(key);
  51.             _dictionary.Add(key, value);
  52.         }
  53.     }
  55.     public void Remove(TKey key)
  56.     {
  57.         if (_dictionary.TryGetValue(key, out _))
  58.         {
  59.             _dictionary.Remove(key);
  60.             _list.Remove(key);
  61.         }
  62.     }
  64.     public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
  65.     {
  66.         foreach (var key in _list)
  67.         {
  68.             yield return new KeyValuePair<TKey, TValue>(key, _dictionary[key]);
  69.         }
  70.     }
  72.     IEnumerator IEnumerable.GetEnumerator()
  73.     {
  74.         return GetEnumerator();
  75.     }
  76. }
  1. var lruCache = new LRUCache<int, int>(4);
  3. lruCache.Put(1, 1);
  4. lruCache.Put(2, 2);
  5. lruCache.Put(3, 3);
  6. lruCache.Put(4, 4);
  8. Console.WriteLine(string.Join(" ", lruCache));
  9. Console.WriteLine(lruCache.Get(2));
  10. Console.WriteLine(string.Join(" ", lruCache));
  11. lruCache.Put(5, 5);
  12. Console.WriteLine(string.Join(" ", lruCache));
  13. lruCache.Remove(3);
  14. Console.WriteLine(string.Join(" ", lruCache));

输出：

  1. [1, 1] [2, 2] [3, 3] [4, 4] // 初始化
  2. 2                           // 访问 2
  3. [1, 1] [3, 3] [4, 4] [2, 2] // 2 移动到链表尾部
  4. [3, 3] [4, 4] [2, 2] [5, 5] // 插入 5
  5. [4, 4] [2, 2] [5, 5]        // 删除 3

算法优化

上面的实现中，对缓存的查询、插入、删除都会涉及到链表中数据的删除（移动也是删除再插入）。

因为我们在 LinkedList 中存储的是 key，所以我们需要先通过 key 在链表中找到对应的节点，然后再进行删除操作，这就导致了链表的删除操作的时间复杂度是 O(n)。

虽然 Dictionary 的查找、插入、删除操作的时间复杂度都是 O(1)，但因为链表操作的时间复杂度是 O(n)，整个算法的最差时间复杂度是 O(n)。

算法优化的关键在于如何降低链表的删除操作的时间复杂度。

优化思路：

  1. 在 Dictionary 中存储 key 和 LinkedList 中节点的映射关系
  2. 在 LinkedList 的节点中存储 key-value

也就是说，我们让两个本来不相关的数据结构之间产生联系。

不管是在插入、删除、查找缓存的时候，都可以通过这种联系来将时间复杂度降低到 O(1)。

  1. 通过 key 在 Dictionary 中找到对应的节点，然后再从 LinkedList 节点中取出 value，时间复杂度是 O(1)
  2. LinkedList 删除数据之前，先通过 key 在 Dictionary 中找到对应的节点，然后再删除，这样就可以将链表的删除操作的时间复杂度降低到 O(1)
  3. LinkedList 删除头部节点时，因为节点中存储了 key，所以我们可以通过 key 在 Dictionary 中删除对应的节点，时间复杂度是 O(1)
  1. public class LRUCache_V2<TKey, TValue> : IEnumerable<KeyValuePair<TKey, TValue>>
  2. {
  3.     private readonly LinkedList<KeyValuePair<TKey, TValue>> _list;
  5.     private readonly Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>> _dictionary;
  7.     private readonly int _capacity;
  9.     public LRUCache_V2(int capacity)
  10.     {
  11.         _capacity = capacity;
  12.         _list = new LinkedList<KeyValuePair<TKey, TValue>>();
  13.         _dictionary = new Dictionary<TKey, LinkedListNode<KeyValuePair<TKey, TValue>>>();
  14.     }
  16.     public TValue Get(TKey key)
  17.     {
  18.         if (_dictionary.TryGetValue(key, out var node))
  19.         {
  20.             _list.Remove(node);
  21.             _list.AddLast(node);
  22.             return node.Value.Value;
  23.         }
  25.         return default;
  26.     }
  28.     public void Put(TKey key, TValue value)
  29.     {
  30.         if (_dictionary.TryGetValue(key, out var node))
  31.         {
  32.             node.Value = new KeyValuePair<TKey, TValue>(key, value);
  33.             _list.Remove(node);
  34.             _list.AddLast(node);
  35.         }
  36.         else
  37.         {
  38.             if (_list.Count == _capacity)
  39.             {
  40.                 _dictionary.Remove(_list.First.Value.Key);
  41.                 _list.RemoveFirst();
  42.             }
  44.             var newNode = new LinkedListNode<KeyValuePair<TKey, TValue>>(new KeyValuePair<TKey, TValue>(key, value));
  45.             _list.AddLast(newNode);
  46.             _dictionary.Add(key, newNode);
  47.         }
  48.     }
  50.     public void Remove(TKey key)
  51.     {
  52.         if (_dictionary.TryGetValue(key, out var node))
  53.         {
  54.             _dictionary.Remove(key);
  55.             _list.Remove(node);
  56.         }
  57.     }
  59.     public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
  60.     {
  61.         return _list.GetEnumerator();
  62.     }
  64.     IEnumerator IEnumerable.GetEnumerator()
  65.     {
  66.         return GetEnumerator();
  67.     }
  68. }

进一步优化

因为我们对 双向链表 的存储需求是定制化的，要求节点中存储 key-value，直接使用 C# 的 LinkedList 我们就需要用 KeyValuePair 这样的结构来间接存储，会导致一些不必要的内存开销。

我们可以自己实现一个双向链表，这样就可以直接在节点中存储 key-value，从而减少内存开销。

  1. public class LRUCache_V3<TKey, TValue>
  2. {
  3.     private readonly DoubleLinkedListNode<TKey, TValue> _head;
  5.     private readonly DoubleLinkedListNode<TKey, TValue> _tail;
  7.     private readonly Dictionary<TKey, DoubleLinkedListNode<TKey, TValue>> _dictionary;
  9.     private readonly int _capacity;
  11.     public LRUCache_V3(int capacity)
  12.     {
  13.         _capacity = capacity;
  14.         _head = new DoubleLinkedListNode<TKey, TValue>();
  15.         _tail = new DoubleLinkedListNode<TKey, TValue>();
  16.         _head.Next = _tail;
  17.         _tail.Previous = _head;
  18.         _dictionary = new Dictionary<TKey, DoubleLinkedListNode<TKey, TValue>>();
  19.     }
  21.     public TValue Get(TKey key)
  22.     {
  23.         if (_dictionary.TryGetValue(key, out var node))
  24.         {
  25.             RemoveNode(node);
  26.             AddLastNode(node);
  27.             return node.Value;
  28.         }
  30.         return default;
  31.     }
  33.     public void Put(TKey key, TValue value)
  34.     {
  35.         if (_dictionary.TryGetValue(key, out var node))
  36.         {
  37.             RemoveNode(node);
  38.             AddLastNode(node);
  39.             node.Value = value;
  40.         }
  41.         else
  42.         {
  43.             if (_dictionary.Count == _capacity)
  44.             {
  45.                 var firstNode = RemoveFirstNode();
  47.                 _dictionary.Remove(firstNode.Key);
  48.             }
  50.             var newNode = new DoubleLinkedListNode<TKey, TValue>(key, value);
  51.             AddLastNode(newNode);
  52.             _dictionary.Add(key, newNode);
  53.         }
  54.     }
  56.     public void Remove(TKey key)
  57.     {
  58.         if (_dictionary.TryGetValue(key, out var node))
  59.         {
  60.             _dictionary.Remove(key);
  61.             RemoveNode(node);
  62.         }
  63.     }
  65.     private void AddLastNode(DoubleLinkedListNode<TKey, TValue> node)
  66.     {
  67.         node.Previous = _tail.Previous;
  68.         node.Next = _tail;
  69.         _tail.Previous.Next = node;
  70.         _tail.Previous = node;
  71.     }
  73.     private DoubleLinkedListNode<TKey, TValue> RemoveFirstNode()
  74.     {
  75.         var firstNode = _head.Next;
  76.         _head.Next = firstNode.Next;
  77.         firstNode.Next.Previous = _head;
  78.         firstNode.Next = null;
  79.         firstNode.Previous = null;
  80.         return firstNode;
  81.     }
  83.     private void RemoveNode(DoubleLinkedListNode<TKey, TValue> node)
  84.     {
  85.         node.Previous.Next = node.Next;
  86.         node.Next.Previous = node.Previous;
  87.         node.Next = null;
  88.         node.Previous = null;
  89.     }
  91.     internal class DoubleLinkedListNode<TKey, TValue>
  92.     {
  93.         public DoubleLinkedListNode()
  94.         {
  95.         }
  97.         public DoubleLinkedListNode(TKey key, TValue value)
  98.         {
  99.             Key = key;
  100.             Value = value;
  101.         }
  103.         public TKey Key { get; set; }
  105.         public TValue Value { get; set; }
  107.         public DoubleLinkedListNode<TKey, TValue> Previous { get; set; }
  109.         public DoubleLinkedListNode<TKey, TValue> Next { get; set; }
  110.     }
  111. }

Benchmark

使用 BenchmarkDotNet 对3个版本进行性能测试对比。

  1. [MemoryDiagnoser]
  2. public class WriteBenchmarks
  3. {
  4.     // 保证写入的数据有一定的重复性，借此来测试LRU的最差时间复杂度
  5.     private const int Capacity = 1000;
  6.     private const int DataSize = 10_0000;
  8.     private List<int> _data;
  10.     [GlobalSetup]
  11.     public void Setup()
  12.     {
  13.         _data = new List<int>();
  14.         var shared = Random.Shared;
  15.         for (int i = 0; i < DataSize; i++)
  16.         {
  17.             _data.Add(shared.Next(0, DataSize / 10));
  18.         }
  19.     }
  21.     [Benchmark]
  22.     public void LRUCache_V1()
  23.     {
  24.         var cache = new LRUCache<int, int>(Capacity);
  25.         foreach (var item in _data)
  26.         {
  27.             cache.Put(item, item);
  28.         }
  29.     }
  31.     [Benchmark]
  32.     public void LRUCache_V2()
  33.     {
  34.         var cache = new LRUCache_V2<int, int>(Capacity);
  35.         foreach (var item in _data)
  36.         {
  37.             cache.Put(item, item);
  38.         }
  39.     }
  41.     [Benchmark]
  42.     public void LRUCache_V3()
  43.     {
  44.         var cache = new LRUCache_V3<int, int>(Capacity);
  45.         foreach (var item in _data)
  46.         {
  47.             cache.Put(item, item);
  48.         }
  49.     }
  50. }
  52. public class ReadBenchmarks
  53. {
  54.     // 保证写入的数据有一定的重复性，借此来测试LRU的最差时间复杂度
  55.     private const int Capacity = 1000;
  56.     private const int DataSize = 10_0000;
  58.     private List<int> _data;
  59.     private LRUCache<int, int> _cacheV1;
  60.     private LRUCache_V2<int, int> _cacheV2;
  61.     private LRUCache_V3<int, int> _cacheV3;
  63.     [GlobalSetup]
  64.     public void Setup()
  65.     {
  66.         _cacheV1 = new LRUCache<int, int>(Capacity);
  67.         _cacheV2 = new LRUCache_V2<int, int>(Capacity);
  68.         _cacheV3 = new LRUCache_V3<int, int>(Capacity);
  69.         _data = new List<int>();
  70.         var shared = Random.Shared;
  71.         for (int i = 0; i < DataSize; i++)
  72.         {
  73.             int dataToPut  = shared.Next(0, DataSize / 10);
  74.             int dataToGet = shared.Next(0, DataSize / 10);
  75.             _data.Add(dataToGet);
  76.             _cacheV1.Put(dataToPut, dataToPut);
  77.             _cacheV2.Put(dataToPut, dataToPut);
  78.             _cacheV3.Put(dataToPut, dataToPut);
  79.         }
  80.     }
  82.     [Benchmark]
  83.     public void LRUCache_V1()
  84.     {
  85.         foreach (var item in _data)
  86.         {
  87.             _cacheV1.Get(item);
  88.         }
  89.     }
  91.     [Benchmark]
  92.     public void LRUCache_V2()
  93.     {
  94.         foreach (var item in _data)
  95.         {
  96.             _cacheV2.Get(item);
  97.         }
  98.     }
  100.     [Benchmark]
  101.     public void LRUCache_V3()
  102.     {
  103.         foreach (var item in _data)
  104.         {
  105.             _cacheV3.Get(item);
  106.         }
  107.     }
  108. }

写入性能测试结果：

  1. |      Method |      Mean |     Error |    StdDev |    Median |     Gen0 |     Gen1 | Allocated |
  2. |------------ |----------:|----------:|----------:|----------:|---------:|---------:|----------:|
  3. | LRUCache_V1 | 16.890 ms | 0.3344 ms | 0.8012 ms | 16.751 ms | 750.0000 | 218.7500 |   4.65 MB |
  4. | LRUCache_V2 |  7.193 ms | 0.1395 ms | 0.3958 ms |  7.063 ms | 703.1250 | 226.5625 |   4.22 MB |
  5. | LRUCache_V3 |  5.761 ms | 0.1102 ms | 0.1132 ms |  5.742 ms | 585.9375 | 187.5000 |   3.53 MB |

查询性能测试结果：

  1. |      Method |      Mean |     Error |    StdDev |    Gen0 | Allocated |
  2. |------------ |----------:|----------:|----------:|--------:|----------:|
  3. | LRUCache_V1 | 19.475 ms | 0.3824 ms | 0.3390 ms | 62.5000 |  474462 B |
  4. | LRUCache_V2 |  1.994 ms | 0.0273 ms | 0.0242 ms |       - |       4 B |
  5. | LRUCache_V3 |  1.595 ms | 0.0187 ms | 0.0175 ms |       - |       3 B |

LRU缓存替换策略及C#实现的更多相关文章

  1. LeetCode：146_LRU cache | LRU缓存设计 | Hard

    题目:LRU cache Design and implement a data structure for Least Recently Used (LRU) cache. It should su ...

  2. 如何使用 LinkedHashMap 实现 LRU 缓存？

    本文已收录到 AndroidFamily,技术和职场问题,请关注公众号 [彭旭锐] 提问. 大家好,我是小彭. 在上一篇文章里,我们聊到了 HashMap 的实现原理和源码分析,在源码分析的过程中,我 ...

  3. LRU缓存实现(Java)

    LRU Cache的LinkedHashMap实现 LRU Cache的链表+HashMap实现 LinkedHashMap的FIFO实现 调用示例 LRU是Least Recently Used 的 ...

  4. 转: LRU缓存介绍与实现 (Java)

    引子: 我们平时总会有一个电话本记录所有朋友的电话,但是,如果有朋友经常联系,那些朋友的电话号码不用翻电话本我们也能记住,但是,如果长时间没有联系了,要再次联系那位朋友的时候,我们又不得不求助电话本, ...

  5. volley三种基本请求图片的方式与Lru的基本使用：正常的加载+含有Lru缓存的加载+Volley控件networkImageview的使用

    首先做出全局的请求队列 package com.qg.lizhanqi.myvolleydemo; import android.app.Application; import com.android ...

  6. 如何用LinkedHashMap实现LRU缓存算法

    阿里巴巴笔试考到了LRU,一激动忘了怎么回事了..准备不充分啊.. 缓存这个东西就是为了提高运行速度的,由于缓存是在寸土寸金的内存里面,不是在硬盘里面,所以容量是很有限的.LRU这个算法就是把最近一次 ...

  7. 面试挂在了 LRU 缓存算法设计上

    好吧,有人可能觉得我标题党了,但我想告诉你们的是,前阵子面试确实挂在了 RLU 缓存算法的设计上了.当时做题的时候,自己想的太多了,感觉设计一个 LRU(Least recently used) 缓存 ...

  8. Java集合详解5：深入理解LinkedHashMap和LRU缓存

    今天我们来深入探索一下LinkedHashMap的底层原理,并且使用linkedhashmap来实现LRU缓存. 摘要: HashMap和双向链表合二为一即是LinkedHashMap.所谓Linke ...

  9. 04 | 链表（上）：如何实现LRU缓存淘汰算法?

    今天我们来聊聊“链表(Linked list)”这个数据结构.学习链表有什么用呢?为了回答这个问题,我们先来讨论一个经典的链表应用场景,那就是+LRU+缓存淘汰算法. 缓存是一种提高数据读取性能的技术 ...

  10. LRU缓存原理

    LRU(Least Recently Used)  LRU是近期最少使用的算法,它的核心思想是当缓存满时,会优先淘汰那些近期最少使用的缓存对象. 采用LRU算法的缓存有两种:LrhCache和DisL ...

随机推荐

  1. qt中的一些对话框(个人备忘录)

    一.标准对话框 1.对于颜色对话框 void MyWidget::on_pushButton_clicked() { QColorDialog dialog(Qt::red,this); dialog ...

  2. 修改tomcat启动时，修改默认访问的页面

    在

  3. 数组扩展（Java）

    Arrays类 基本介绍 数组的工具类java.util.Arrays 由于数组本身中没有什么方法可供我们调用,但API中提供了一个工具类Arrays供我们使用,从而可以对数据对象进行一些基本操作 查 ...

  4. 更多Linux实用命令

    更多实用命令 进程相关 当程序运行在系统上时,我们称之为进程(process).想监测这些进程,需要熟悉 ps/top 等命令的用法.ps 命令好比工具中的瑞士军刀,它能输出运行在系统上的所有程序的许 ...

  5. CSS 常用样式-盒模型属性

    盒模型又叫框模型,包含了五个用来描述盒子位置.尺寸的属性,分别是宽度 width.高度 height.内边距 padding. 边框 border.外边距 margin. 常见盒模型区域: • 盒模型 ...

  6. 洛谷 P1832 A+B Problem（再升级）题解

    START: 2021-08-09 15:28:07 题目链接: https://www.luogu.com.cn/problem/P1832 给定一个正整数n,求将其分解成若干个素数之和的方案总数. ...

  7. Jenkins集成appium自动化测试

    一,引入问题 自动化测试脚本绝大部分用于回归测试,这就需要制定执行策略,如每天.代码更新后.项目上线前定时执行,才能达到最好的效果,这时就需要进行Jenkins集成. 不像web UI自动化测试可以使 ...

  8. 大数据组件对应Ranger插件的选择

    在都是开源组件的前提下,一般需要我们多关注到组件和插件的版本和类型选择. 参考 https://zhuanlan.zhihu.com/p/370263573 https://www.bookstack ...

  9. bash中的basename与dirname以及${}

    var=/dir1/dir2/file.tar.gz basename $var        #获取文件名 file.tar.gz dirname $var            #获取目录名称 / ...

  10. flask - fastapi （python 异步API 框架 可以自动生成swagger 文档） 常用示例 以及整合euraka nacos

    flask - fastapi    (python 异步API 框架  可以自动生成swagger 文档)  常用示例: 之前使用 flask 需要手动写文档, 这个可以自动生成, fastapi ...