最近使用的最少使用缓存（LRU Cache）算法

最新推荐文章于 2024-05-23 22:10:14 发布
最新推荐文章于 2024-05-23 22:10:14 发布
阅读量320 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： 缓存 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/StVariable/article/details/133304385
算法 专栏收录该内容
51 篇文章 ¥59.90 ¥99.00
订阅专栏
LRU缓存算法基于最近最少使用原则，用于高效管理缓存。文章详细阐述了其原理，采用哈希表和双向链表的实现方式，并列举了数据库系统、操作系统和Web应用等应用场景。还提供了Python实现的LRU缓存示例。

LRU缓存算法是一种常用的缓存替换策略，它基于最近最少使用的原则，将最近最少使用的数据项从缓存中淘汰。本文将详细介绍LRU缓存算法的原理和应用，并提供相应的源代码实现。

LRU缓存算法原理

LRU缓存算法的核心思想是基于数据项的访问历史来决定哪些数据项是最近最少使用的。每当访问一个数据项时，该数据项被标记为最近使用的，并移动到缓存的首部（或者说是最新位置）。当缓存已满并需要淘汰数据项时，最近最少使用的数据项将会被移除，以便为新的数据项腾出空间。

LRU缓存算法的实现可以使用哈希表和双向链表结合的方式。哈希表用于快速查找数据项，而双向链表用于维护数据项的访问顺序。每个节点包含数据项的键值对，并通过前后指针连接形成双向链表。

LRU缓存算法的应用

LRU缓存算法在实际应用中具有广泛的应用场景，特别适用于需要高效访问和操作最近数据的场景。以下是一些常见的应用场景：

  1. 数据库系统：在数据库系统中，LRU缓存算法经常被用于缓存最常访问的数据块，以提高查询性能。

  2. 操作系统：操作系统中的文件缓存系统通常使用LRU缓存算法来管理磁盘访问，以减少IO操作的次数。

  3. Web应用程序：Web服务器中使用LRU缓存算法来缓存最频繁访问的网页或资源文件，以提高响应速度。

  4. 图形处理：图形处理中的纹理缓存通常使用LRU缓存算法来存储最常用的纹理数据，以提高渲染性能。

源代码实现

下面是一个使用Python实现的LRU缓存算法示例：


                

                
                
        

    


  


        

                

                  

                  

                  了解本专栏
                  
                  
                    
                  订阅专栏 解锁全文
                   
                

        


    



                



	

		

			

				
					
最近最少使用的缓存机制，完整实现

				
			

			

				

					算法channel
				

				

					06-19
					
					386
					
				

			

		

		

			
				
你好，我是zhenguo今天结合一道leetcode有意思的题目，设计和实现一个 LRU (最近最少使用) 缓存机制，顺便和读者们加强下双向链表、字典这些数据结构的应用能力。链表增删操作...

			
		

	



                

            
              



	

		

			

				
					
图解缓存淘汰算法 LRU、LFU ｜ 最近最少使用、最不经常使用算法 ｜ go语言实现

				
			

			

				

					m0_74825360的博客
				

				

					03-02
					
					942
					
				

			

		

		

			
				
无论是什么系统，在研发的过程中不可避免的会使用到缓存，而缓存一般来说我们不会永久存储，但是缓存的内容是有限的，那么我们如何在有限的内存空间中，尽可能的保留有效的缓存信息呢？那么我们就可以使用 LRU/LFU算法，来维持缓存中的信息的时效性。

			
		

	



              


  
              

                


	

		

			

				
					
最近最少使用缓存

				
			

			

				

					w17319185551的博客
				

				

					05-23
					
					522
					
				

			

		

		

			
				
Hashmap的get和put方法时间复杂度是O(1)，但其不能找出最近最少使用的键。而要想表示一种顺序关系，不难想到可以使用链表，将链尾视为最近最少使用的元素，每次访问一个元素，将该元素移到链头。而将元素移到链头之前，应先将节点从原来位置删掉，若仅仅知道待删除节点，是不能知道前驱节点的，故单链表的增删操作复杂度为O (n)。所以我们需使用双向链表。题目：请设计实现一个最近最少使用缓存，要求如下两个操作的时间复杂度都是O(1)。用哈希表的键保存key，哈希表的值保存双向链表的节点。

			
		

	





	

		

			

				
					
leetcode/LRU (Least Recently Used) 最近最少使用缓存

				
			

			

				

					求道问术
				

				

					08-18
					
					379
					
				

			

		

		

			
				
* 剑指 Offer II 031. 最近最少使用缓存
 * 运用所掌握的数据结构，设计和实现一个  LRU (Least Recently Used，最近最少使用) 缓存机制 。
 * 
 * LRU：操作系统/内存管理/内存分配/离散分配/请求分页方式/页面置换算法/LRU(最近最少使用)
 * - 队列数据结构，队列长度固定，队尾进入，对头出，如果队尾进入元素已经在队列中则把队列中的元素去掉再放入队列，队列满了对头才出1个元素再放入要进入的元素
 * 
 * 实现 LRUCache 类：...

			
		

	



		

			
		



	

		

			

				
					
LeetCode 146 LRU缓存机制（中等）

				
			

			

				

					嗷嗷嗷嗷的博客
				

				

					11-10
					
					162
					
				

			

		

		

			
				
运用你所掌握的数据结构，设计和实现一个  LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达到上限时，它应该在写入新数据之前删除最

			
		

	





	

		

			

				
					
LRU– 最近最少使用缓存

				
			

			

				

					qq_45838562的博客
				

				

					08-31
					
					365
					
				

			

		

		

			
				
LRU– 最近最少使用缓存
怕下次找不到了？快快点关注鼓励一下嘛~ (╹▽╹) ~
题目：
设计一个数据结构，实现LRU Cache的功能(Least Recently Used – 最近最少使用缓存)。它支持如下2个操作： get 和 put。get： 如果key已存在，则返回key对应的值value（始终大于0）；如果key不存在，则返回-1。put：如果key不存在，将value插入；如果key已存在，则使用value替换原先已经存在的值。如果容量达到了限制，LRU Cache需要在插入新元素之前，将

			
		

	





	

		

			

				
					
cachelru:最近最少使用算法

				
			

			

				

					06-05
				

			

		

		

			
				
其中，“最近最少使用算法”（Least Recently Used, LRU）是缓存淘汰策略的一种常见实现，尤其在JavaScript开发中被广泛采用。  LRU算法基于一个假设：最近频繁使用的数据在将来也更可能被频繁使用。因此，当缓存...

			
		

	





	

		

			

				
					
剑指 Offer II 031. 最近最少使用缓存

				
			

			

				

					m0_48711099的博客
				

				

					07-22
					
					344
					
				

			

		

		

			
				
哈希表与双向链表的数据结构

			
		

	





	

		

			

				
					
[LeetCode]146. LRU 缓存机制

				
			

			

				

					张小猪的家
				

				

					08-27
					
					297
					
				

			

		

		

			
				
146. LRU 缓存机制
难度：中等
运用你所掌握的数据结构，设计和实现一个 LRU (最近最少使用) 缓存机制 。
实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量 capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value) 如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」。当缓存容量达

			
		

	





	

		

			

				
					
通关剑指 Offer——剑指 Offer II 031. 最近最少使用缓存

				
			

			

				

					SK_Jaco的博客
				

				

					09-16
					
					448
					
				

			

		

		

			
				
通关剑指 Offer——剑指 Offer II 031. 最近最少使用缓存

			
		

	





	

		

			

				
					
【leetcode】【剑指offer Ⅱ】031. 最近最少使用缓存

				
			

			

				

					做一些记录工作。
				

				

					08-18
					
					244
					
				

			

		

		

			
				
【leetcode】【剑指offer Ⅱ】031. 最近最少使用缓存。

			
		

	





	

		

			

				
					
leetcode：146. LRU最近最少使用 缓存

				
			

			

				

					OceanStar的博客
				

				

					07-19
					
					310
					
				

			

		

		

			
				
如果容量不够，那么要求删除最近最少使用的。

			
		

	





	

		

			

				
					
剑指offer_31 最近最少使用缓存

				
			

			

				

					weixin_43817702的博客
				

				

					01-09
					
					133
					
				

			

		

		

			
				
题目：


运用所掌握的数据结构，设计和实现一个LRU (Least Recently Used，最近最少使用) 缓存机制 。

实现 LRUCache 类：

LRUCache(int capacity) 以正整数作为容量capacity 初始化 LRU 缓存
int get(int key) 如果关键字 key 存在于缓存中，则返回关键字的值，否则返回 -1 。
void put(int key, int value)如果关键字已经存在，则变更其数据值；如果关键字不存在，则插入该组「关键字-值」...

			
		

	





	

		

			

				
					
剑指offer31：最近最少使用缓存

				
			

			

				

					L的博客
				

				

					10-13
					
					244
					
				

			

		

		

			
				
题目：
请设计实现一个最近最少使用（LRU）缓存，要求如下两个操作的时间复杂度都是O（1）。
1.get(key):如果缓存中存在键key，则返回它对应的值：否则返回-1。
2.put(key,value):如果缓存中之前包含键key，则它的值设为value，否则添加键key以及对应的值value。在添加一个键时，如果缓存已经满了，则在添加新键之前删除最近最少使用的键（缓存中最长时间没有被使用过的元素）
分析：

a图是一个容量为4的最近最少使用缓存，依次插入四个键值对后，先后在双向链表中插入4个节点。
b

			
		

	





	

		

			

				
					
LRU(最近最少使用)缓存机制

				
			

			

				

					StriveZs'Blog
				

				

					07-19
					
					677
					
				

			

		

		

			
				
title: LRU缓存机制
categories:

操作系统

tags:

操作系统
LRU
OS
计算机知识


LRU(最近最少使用)缓存机制
LRU：最近最少使用缓存机制
其设计的原则依据：如果一个数据在最近一段时间没有被访问到，那么在将来它被访问的可能性也很小。也就是说，当限定的空间已存满数据时，应当把最久没有被访问到的数据淘汰。
假定系统为某进程分配了3个物理块，进程运行时的页面走向为 7 0 1 2 0 3 0 4，开始时3个物理块均为空，那么LRU算法是如下工作的：

上述操纵通过一个.

			
		

	





	

		

			

				
					
LRU最近最少使用的缓存

				
			

			

				

					qq_46724069的博客
				

				

					10-10
					
					540
					
				

			

		

		

			
				
实现思路，在LRU缓存类中维护一个Node的内部类，和一个缓存Map，实现每一个value就是一个Entry，entry之间是双向链表的关系，在链表之间加入head，和tail的entry节点，所有的数据节点都是在这两个之间进行的插入和查询。通过传入的指定的一个key，获取到对应的节点Entry，如何获取到的节点为null的话就是没有此节点，返回-1即可。的方法就比较麻烦了，通过key获取到节点node，此节点不为空，就说明缓存中具有此节点，更新此节点的value，将此节点移动到头部，返回即可。

			
		

	





	

		

			

				
					
LRU近期最少使用算法cache替换算法

					
最新发布

				
			

			

				

					11-22
				

			

		

		

			
				
### 原理
LRU（近期最少使用）算法作为 cache 替换算法的核心原理是，当 cache 满时，优先淘汰近期最少使用的数据。其依据是程序的局部性原理，即如果一个数据在最近一段时间内没有被访问，那么在未来一段时间内被访问的可能性也相对较低。在 cache 管理中，凡是被访问（新建、修改命中、访问命中）过的节点，会被视为近期使用过的数据，而长时间未被访问的节点则是近期最少使用的数据，在 cache 空间不足需要替换时，会优先替换这些节点 [^2]。

### 实现
LRU 算法通常使用双向链表和哈希表（HashMap）结合的方式实现。双向链表用于维护缓存节点的访问顺序，哈希表用于实现快速的节点查找。具体实现步骤如下：
- 维护一个双向链表，其中每个节点代表一个缓存项。凡是被访问（新建/修改命中/访问命中）过的节点，在访问完成后移动到双向链表尾部，这样能保证链表尾部始终为最新节点，链表头部始终为最旧节点。
- 使用哈希表存储键值对 `<key, CacheNode>`，其中 `key` 是缓存项的键，`CacheNode` 是双向链表中的节点。通过哈希表可以在 $O(1)$ 的时间复杂度内查找缓存项。
- 当进行缓存访问时，如果缓存命中，将对应的节点移动到双向链表尾部；如果缓存未命中，创建新节点添加到双向链表尾部，并将其插入哈希表中。若此时 cache 已满，则删除双向链表头部的节点，并从哈希表中移除对应的键值对。

以下是使用 Python 实现 LRU 缓存的示例代码：
```python
class DLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = {}
        self.size = 0
        self.capacity = capacity
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def _add_to_tail(self, node):
        node.prev = self.tail.prev
        node.next = self.tail
        self.tail.prev.next = node
        self.tail.prev = node

    def _remove_node(self, node):
        node.prev.next = node.next
        node.next.prev = node.prev

    def _move_to_tail(self, node):
        self._remove_node(node)
        self._add_to_tail(node)

    def _remove_head(self):
        node = self.head.next
        self._remove_node(node)
        return node

    def get(self, key: int):
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self._move_to_tail(node)
        return node.value

    def put(self, key: int, value: int):
        if key in self.cache:
            node = self.cache[key]
            node.value = value
            self._move_to_tail(node)
        else:
            node = DLinkedNode(key, value)
            self.cache[key] = node
            self._add_to_tail(node)
            self.size += 1
            if self.size > self.capacity:
                removed = self._remove_head()
                self.cache.pop(removed.key)
                self.size -= 1
```

### 应用
- **操作系统内存管理**：在操作系统中，内存是一种有限的资源，LRU 算法可以用于页面置换。当物理内存不足时，操作系统需要将一些页面从内存中换出到磁盘，使用 LRU 算法可以优先选择近期最少使用的页面进行换出，从而提高内存的使用效率。
- **数据库缓存**：数据库系统通常会使用缓存来提高数据的访问速度。例如，数据库的查询缓存可以使用 LRU 算法来管理缓存项，当缓存满时，淘汰近期最少使用的查询结果，以保证缓存中始终存储着最常用的数据。
- **浏览器缓存**：浏览器在本地存储网页资源（如图片、脚本文件等）时，也会使用缓存替换算法。LRU 算法可以帮助浏览器在缓存空间不足时，优先删除近期最少使用的资源，从而为新的资源腾出空间。

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

  
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值