用 Go 实现一个 LRU cache

Go语言实现LRU缓存
最新推荐文章于 2025-04-23 07:03:47 发布
原创 最新推荐文章于 2025-04-23 07:03:47 发布 · 323 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #数据结构 #java #redis #spring

本文介绍如何使用Go语言实现LRU缓存，并应用于性能测试工具ptg中，以存储和检索请求历史记录。

609fd41f0292c4df4cbde3aba98be3b2.png

前言

早在几年前写过关于 LRU cache 的文章：https://crossoverjie.top/2018/04/07/algorithm/LRU-cache/

当时是用 Java 实现的，最近我在完善 ptg 时正好需要一个最近最少使用的数据结构来存储历史记录。

ptg: Performance testing tool (Go), 用 Go 实现的 gRPC 客户端调试工具。

Go 官方库中并没有相关的实现，考虑到程序的简洁就不打算依赖第三方库，自己写一个；本身复杂度也不高，没有几行代码。

配合这个数据结构，我便在 ptg 中实现了请求历史记录的功能：

将每次的请求记录存储到 lru cache 中，最近使用到的历史记录排在靠前，同时也能提供相关的搜索功能；具体可见下图。

b21574554ea17285ee016c751d727fae.gif

实现

284a132867f24bf561d3477901a3315c.png

实现原理没什么好说的，和 Java 的一样：

  • 一个双向链表存储数据的顺序

  • 一个 map 存储最终的数据

  • 当数据达到上限时移除链表尾部数据

  • 将使用到的 Node 移动到链表的头结点

虽然 Go 比较简洁，但好消息是基本的双向链表结构还是具备的。

60cc39bf7de2c04f8d95d2867a28bcb2.png

所以基于此便定义了一个 LruCache:

391055a057f4b3c00f8a559f2aba1937.png

根据之前的分析：

  • size 存储缓存大小。

  • 链表存储数据顺序。

  • map 存储数据。

  • lock 用于控制并发安全。

9d180a8620d10e4b5487077140c67c5d.png

接下来重点是两个函数：写入、查询。

写入时判断是否达到容量上限，达到后删除尾部数据；否则就想数据写入头部。

而获取数据时，这会将查询到的结点移动到头结点。

这些结点操作都由 List 封装好了的。98854d20949f0a616c30f1c92457950c.png

所以使用起来也比较方便。

最终就是通过这个 LruCache 实现了上图的效果，想要了解更多细节的可以参考源码:

https://github.com/crossoverJie/ptg/blob/main/gui/lru.go

ba8c2c6ee0e9afaa568155e1c37fafd5.png

撸了一个可调试 gRPC 的 GUI 客户端


3bd0b2232c9e47e8a06ff03a78a8138c.png

编写一个接口压测工具


091f2b9514a592e96398d6c87e51a025.png

效率提高80%，Go开发必备的库与工具！


3e2af95616ef104b5517eff7995ec5e3.png

DDD 到底是银弹还是垃圾


955a2140350ff8f1ee7ddf2fb879cd74.png

观察者模式的实际应用


90e32aec9e4845182a07bf2236e3860a.png

[]*T *[]T *[]*T 傻傻分不清楚


3d63bfc7ec2b7691c7646382e3a70674.png

点个在看你最好看

crossoverJie
关注
golang-lru Cache （一）LRU
Uncle_Y的专栏
07-31 6068
简介 Golang 第三方库golang-lru基于双向链表实现了三种LRU及变种Cache：LRU，Q2，ARC。今天看了一下代码，简单优雅，整理一下笔记。 双向链表 双向链表在golang标准库container/list中实现。定义了两个核心结构体Element和List。 Element 双向链表的一个节点信息。 type Element struct { ...
Golang实现LRU Cache
skh2015java的博客
02-25 714
146. LRU Cache 运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。 实现 LRUCache 类： LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存 int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。 void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到.
Go-一个简单高效用于go的LRU缓存包
08-13
一个简单高效用于go的LRU缓存包
Go实现LRU Cache
做兴趣使然的Hero
02-19 541
1 基本概念 LRU是一个老生常谈的问题，即最近最少使用，LRU是Least Recently Used的缩写，是一种操作系统中常用的页面置换算法，选择最近最久未使用的页面予以淘汰。该算法赋予每个页面一个访问字段，用来记录一个页面自上次被访问以来所经历的时间 t，当须淘汰一个页面时，选择现有页面中其 t 值最大的，即最近最少使用的页面予以淘汰。 实现LRU基本的数据结构：Map+LinkedList 一般规则： 添加数据时，将新增数据节点放在头指针，尾结点部分大于最大长度时删除。 删除数据时，先按照Ma
数据结构-LRU缓存go实现
u014306722的博客
04-15 426
LRU缓存 直接看代码 package lru import ( "container/list" "sync" ) // LRU缓存结构 type LRUCache struct { // 缓存容量 capacity int // 缓存链表 list *list.List // 缓存数据 cache map[interface{}]*list.Element // 访问锁 lock sync.RWMutex } type ElementValue struct { Key
使用 Go 语言实现 LRU 缓存
tatasix的博客
10-31 1497
本文深入探讨了 LRU 缓存的实现原理，结合 Go 语言，设计了一种基于双向链表和哈希表的数据结构来实现高效的缓存。文章详细介绍了节点初始化、插入、更新、淘汰等操作，并配以图示帮助读者理解链表操作的细节。
golang expired LRU cache（key有过期时间的，实现了LRU算法的cache）
liyunlonghere
12-29 2718
github地址：https://github.com/hackssssss/lru_expired_cache 之前实现了lru算法的cache，链接，后来发现可以添加key自动过期的策略，采用惰性过期策略。即当get或者set这个key时，才去更新key的状态，如果过期，那么将其删除。 package lru_expiredcache import ( "container/list...
Golang实现LRU算法~
luyaran的博客
11-13 2481
原文地址：Golang实现LRU算法~ LRU是LeastRecentlyUsed的缩写，即最近最少使用，是一种常用的缓存淘汰算法，选择最近最久未使用的数据予以淘汰，该算法赋予每个数据一个访问字段，用来记录一个元素自上次被访问以来所经历的时间t，当须淘汰一个数据时，选择现有数据中其t值最大的，即最近最少使用的页面予以淘汰。 Go可用链表数据结构来省去设置访问时间t字段，可将经常访问的数据插入链表头，而链表尾部的数据自然就成为最久未访问的数据。 代码实现如下： package mainim...
LRU cache原理及go实现
javagty6778的博客
01-11 221
缓存资源通常比较昂贵,通常数据量较大时,会竟可能从较少的缓存满足尽可能多访问,这里有一种假设,通常最近被访问的数据,那么它就有可能会被后续继续访问,基于这种假设,将所有的数据按访问时间进行排序,并按驱逐出旧数据,那么存在缓存的数据就为热点数据,这样既节省了内存资源,又极大的满足了访问.LRU(Least recently used)算法就是基于这种假设的一直缓存置换算法.
LRU go cache的实现
General_zy的博客
09-08 1764
一致性哈希算法是Cache 从单节点走向分布式节点的一个重要的环节。对于分布式缓存来说，当一个节点接收到请求，如果该节点并没有存储缓存值，那么它面临的难题是，从谁那获取数据？自己，还是节点1, 2, 3, 4…。假设包括自己在内一共有 10 个节点，当一个节点接收到请求时，随机选择一个节点，由该节点从数据源获取数据。假设第一次随机选取了节点 1 ，节点 1 从数据源获取到数据的同时缓存该数据；
Go-GCache-golang的缓存库它支持expirable缓存LFULRU和ARC
08-14
GCache - golang的缓存库，它支持expirable缓存、LFU LRU和ARC。
Golang中的一个LRU cache实现
chuodun4566的博客
01-19 560
完整代码在：https://github.com/xiaonanln/golrucache packagelrucache import"time" typeLRUCachestruct{ timeouttime.Duration cachemap[string]l...
go语言实现LRU缓存
weixin_46529397的博客
02-09 1096
设计和构建一个“最近最少使用”缓存，该缓存会删除最近最少使用的项目。缓存应该从键映射到值(允许你插入和检索特定键对应的值)，并在初始化时指定最大容量。当缓存被填满时，它应该删除最近最少使用的项目。写入数据 put(key, value) - 如果密钥不存在，则写入其数据值。当缓存容量达到上限时，它应该在写入新数据之前删除最近最少使用的数据值，从而为新的数据值留出空间。获取数据 get(key) - 如果密钥 (key) 存在于缓存中，则获取密钥的值（总是正数），否则返回 -1。
golang--算法--LRU 缓存淘汰算法
天天water的专栏
02-29 4654
前言： 说到链表一个经典的应用场景，那就是 LRU 缓存淘汰算法。 缓存是一种提高数据读取性能的技术，在硬件设计、软件开发中都有着非常广泛的应用，比如常见的 CPU 缓存、数据库缓存、浏览器缓存等等。缓存的大小有限，当缓存被用满时，哪些数据应该被清理出去，哪些数据应该被保留？这就需要缓存淘汰策略来决定。常见的策略有三种：先进先出策略 FIFO（First In，First Out）、最少使用策...
Golang玩转LRUcache
qq_26728375的博客
06-27 419
大家好！众所周知，作为一名合格的程序猿，不断地学习和交流是提升的关键。今天，一夕和大家一起来了解下LRU缓存淘汰。 先介绍下LRUcache。大家都知道，缓存在任何稍具规模的项目里，都有着举足轻重的地位，而对于性能要求高的系统，缓存都是使用内存的，大小受限。那么当缓存空间被用满时，哪些数据应该被清理出去？这就需要缓存淘汰策略来决定。常见的策略有三种：FIFO（First In，First Out）、LFU（Least Frequently Used）、LRU（Least Recently Used）。今天
golang LRU Cache
热门推荐
liyunlonghere
12-28 2万+
github地址：https://github.com/hackssssss/lruCache 用golang中的map与list双向链表实现了lru（最久未使用）算法，map value中存放数据以及key在list中的地址，list中存放map的key，当set或者get时，从map中获取key在list中的地址，将其删除（list是双向链表，删除复杂度O1），并在list尾部添加新的key...
Go的数据结构与实现【LRU Cache】
ldxxxxll的博客
04-02 703
在本文中，我们将用Go实现LRU Cache。
Golang从0到1实现简易版expired LRU cache带图解
最新发布
weixin_55010563的博客
04-23 512
要想实现O(1)的Put，并且能当容量满了的时候自动弹出最久未使用的元素，单纯使用哈希表是比较难实现的，因此我们可以使用一个双向链表，头部存放最新被使用的节点，尾部存放最久未使用的节点。这里可以采用一个懒更新的策略，当调用Get获取到一个节点的时候，应该检查是否已经过期，过期了就应该去除掉这个节点，给用户返回-1。接着，我们希望当LRU存在节点的时候，再进行检查是否过期，为了防止协程长期自旋检查，我们可以为LRUcache添加一个sycn.Cond，做到当没有节点的时候，就可以沉睡等待被唤醒。
用go实现一个lru缓存
09-01
### 回答1： 我可以给你一些简单的步骤来实现LRU缓存：1. 使用一个哈希表来存储键和值的映射。2. 使用一个双端链表来存储键，以按照访问顺序排列。3. 如果键存在于缓存中，将其移动到双端链表的头部，表示这个键最近被访问了。4. 如果缓存容量已满，则将尾部的键删除，以便空出空间。 ### 回答2： 要用Go语言实现一个LRU（Least Recently Used）缓存，可以使用该语言提供的一些数据结构和函数来简化操作。 首先，我们需要创建一个结构体来表示缓存项。每个缓存项包含键和值两个字段。 ```go type CacheItem struct { key string value interface{} } ``` 接下来，我们创建一个结构体来表示LRU缓存，其中包含一个哈希表和一个双向链表。 ```go type LRUCache struct { capacity int cacheMap map[string]*list.Element cacheList *list.List } ``` 在LRUCache结构体中，哈希表cacheMap用于存储键和对应链表元素的映射关系，以便在O(1)时间复杂度内快速访问缓存项。双向链表cacheList用于存储实际的缓存项，其中最近被访问的项放在链表头部，最久未被访问的项放在链表尾部。 接下来，我们来实现LRUCache的一些方法： 1. 初始化缓存。 ```go func NewLRUCache(capacity int) *LRUCache { return &LRUCache{ capacity: capacity, cacheMap: make(map[string]*list.Element), cacheList: list.New(), } } ``` 2. 获取缓存项。 ```go func (c *LRUCache) Get(key string) (interface{}, bool) { if element, ok := c.cacheMap[key]; ok { c.cacheList.MoveToFront(element) return element.Value.(*CacheItem).value, true } return nil, false } ``` 3. 插入缓存项。 ```go func (c *LRUCache) Put(key string, value interface{}) { if element, ok := c.cacheMap[key]; ok { c.cacheList.MoveToFront(element) element.Value.(*CacheItem).value = value } else { if c.cacheList.Len() >= c.capacity { tail := c.cacheList.Back() delete(c.cacheMap, tail.Value.(*CacheItem).key) c.cacheList.Remove(tail) } element := c.cacheList.PushFront(&CacheItem{ key: key, value: value, }) c.cacheMap[key] = element } } ``` 在插入缓存项时，首先检查是否已存在该键。如果存在，则将缓存项移到链表头部，同时更新对应的值。如果不存在，则检查缓存容量是否已满，如果已满，则删除链表尾部的缓存项，并从哈希表中删除对应的键；然后，插入新的缓存项到链表头部，并在哈希表中添加对应的键和链表元素的映射关系。 这样，就可以用Go语言实现一个LRU缓存了。 ### 回答3： 使用Go语言实现一个LRU（Least Recently Used）缓存可以通过使用哈希表和双向链表来实现。 首先，我们需要定义一个缓存结构体，其中包含一个哈希表和两个链表指针，分别用于存储缓存的键值对和维护访问顺序。 ```go type LRUCache struct { capacity int cache map[int]*Node head *Node tail *Node } type Node struct { key int value int prev *Node next *Node } ``` 在初始化LRU缓存时，我们需要指定缓存的容量并创建一个空的哈希表。 ```go func NewLRUCache(capacity int) *LRUCache { return &LRUCache{ capacity: capacity, cache: make(map[int]*Node), head: nil, tail: nil, } } ``` 接下来，我们需要实现四个核心的功能方法：获取缓存值、添加新的缓存值、移动已存在的缓存值到链表头部以及移除最久未使用的缓存。 首先，我们实现Get方法用于获取缓存值。当需要获取某个缓存值时，如果该值存在于哈希表中，我们需要将其移动到链表头部表示最近被访问过，并返回其值。否则，返回-1表示该缓存值不存在。 ```go func (l *LRUCache) Get(key int) int { if node, ok := l.cache[key]; ok { l.moveToHead(node) return node.value } return -1 } ``` 其次，我们实现Put方法用于添加新的缓存值。当需要添加新的缓存值时，首先判断该值是否已存在于哈希表中，如果存在，则更新该值的节点，并将节点移动到链表头部。如果不存在，检查缓存是否已满，如果已满，则需要移除链表尾部的节点，并从哈希表中删除相应的键。最后，创建一个新节点，并将其添加到链表头部和哈希表中。 ```go func (l *LRUCache) Put(key int, value int) { if node, ok := l.cache[key]; ok { node.value = value l.moveToHead(node) return } if len(l.cache) == l.capacity { delete(l.cache, l.tail.key) l.removeTail() } newNode := &Node{ key: key, value: value, prev: nil, next: nil, } l.addToHead(newNode) l.cache[key] = newNode } ``` 最后，我们需要实现两个辅助方法moveToHead和removeTail，分别用于将某个节点移动到链表头部和移除链表尾部的节点。 ```go func (l *LRUCache) moveToHead(node *Node) { if node == l.head { return } l.removeNode(node) l.addToHead(node) } func (l *LRUCache) removeTail() { if l.tail == nil { return } if l.tail == l.head { l.head = nil l.tail = nil return } l.tail = l.tail.prev l.tail.next = nil } func (l *LRUCache) removeNode(node *Node) { if node.prev != nil { node.prev.next = node.next } else { l.head = node.next } if node.next != nil { node.next.prev = node.prev } else { l.tail = node.prev } } func (l *LRUCache) addToHead(node *Node) { node.prev = nil node.next = l.head if l.head != nil { l.head.prev = node } l.head = node if l.tail == nil { l.tail = node } } ``` 至此，我们通过使用哈希表和双向链表实现了一个LRU缓存。这样，我们可以在O(1)的时间复杂度下对缓存进行读和写操作。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值