LRU演算法簡介

落雷發表於2024-07-06
演算法

LRU（Least Recently Used，最近最少使用）演算法是一種常用於快取管理的演算法，用於在快取空間有限的情況下，決定哪些資料應該被移除。它的基本思想是：如果一個資料最近被訪問過，那麼在將來一段時間內它被再次訪問的機率較高。因此，當快取已滿，需要移除資料時，優先移除那些最近最少被使用的資料。

LRU演算法的基本概念

  1. 快取命中（Cache Hit）：當訪問的資料已經在快取中時，稱為快取命中。
  2. 快取未命中（Cache Miss）：當訪問的資料不在快取中，需要從外部儲存載入資料時，稱為快取未命中。
  3. 快取替換（Cache Replacement）：當快取已滿，需要替換掉某些資料以騰出空間時，稱為快取替換。

LRU演算法的實現

LRU演算法的實現通常需要兩個資料結構：

  1. 雜湊表（Hash Table）：用於快速訪問快取中的資料。
  2. 雙向連結串列（Doubly Linked List）：用於維護資料的使用順序，連結串列頭部是最近使用的資料，尾部是最久未使用的資料。

LRU快取的操作

  1. 訪問資料：
    • 如果資料在快取中（快取命中），將其移動到連結串列頭部。
    • 如果資料不在快取中（快取未命中），將資料插入到連結串列頭部。
      • 如果快取已滿，移除連結串列尾部的資料，以騰出空間。
  2. 插入資料：
    • 將資料插入到連結串列頭部。
    • 更新雜湊表，使其指向新節點。
    • 如果快取已滿，移除連結串列尾部的資料，並在雜湊表中刪除相應的項。

Go示例

package lru

import (
	"container/list"
	"sync"
)

type LRUCache struct {
	mtx      sync.Mutex            // protects the cache
	capacity int                   // capacity of the cache
	cache    map[any]*list.Element // nearly O(1) lookups
	list     *list.List            // O(1) insert, update, delete
}

// NewLRUCache creates a new LRU cache with the given capacity.
func NewLRUCache(capacity int) *LRUCache {
	return &LRUCache{
		capacity: capacity,
		cache:    make(map[any]*list.Element),
		list:     list.New(),
	}
}

// Contains checks if the given item is in the cache.
// This function is safe for concurrent access.
func (c *LRUCache) Contains(item any) bool {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	node, exists := c.cache[item]
	if exists {
		c.list.MoveToFront(node)
	}
	return exists
}

// Get returns the item from the cache.
// This function is safe for concurrent access.
func (c *LRUCache) Get(item any) any {
	node, exists := c.cache[item]
	if exists {
		c.mtx.Lock()
		c.list.MoveToFront(node)
		c.mtx.Unlock()
		return node.Value
	} else {
		c.Add(item)
		return item
	}
}

// Add adds the given item to the cache.
// This function is safe for concurrent access.
func (c *LRUCache) Add(item any) {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	// if capacity is 0, nothing can be added, so just return
	if c.capacity == 0 {
		return
	}

	// check if the item is already in the cache
	if node, exists := c.cache[item]; exists {
		c.list.MoveToFront(node)
		return
	}

	// if the cache is full, remove the last element
	if c.list.Len() == c.capacity {
		last := c.list.Back()
		c.list.Remove(last)
		delete(c.cache, last.Value)
	}

	// add the new item to the front of the list
	node := c.list.PushFront(item)
	c.cache[item] = node
}

// Delete removes the given item from the cache if exists.
// This function is safe for concurrent access.
func (c *LRUCache) Delete(item any) {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	// check if the item is already in the cache
	if node, exists := c.cache[item]; exists {
		c.list.Remove(node)
		delete(c.cache, item)
	}
}

// Len returns the number of items in the cache.
// This function is safe for concurrent access.
func (c *LRUCache) Len() int {
	c.mtx.Lock()
	defer c.mtx.Unlock()

	return c.list.Len()
}
孟斯特

宣告：本作品採用署名-非商業性使用-相同方式共享 4.0 國際 (CC BY-NC-SA 4.0)進行許可，使用時請註明出處。
Author: mengbin
blog: mengbin
Github: mengbin92
cnblogs: 戀水無意
騰訊雲開發者社群：孟斯特

相關文章