Array implementa estratégia de eliminação de cache LRU

Introdução ao LRU

O algoritmo de eliminação de cache LRU é uma estratégia comum. O nome completo de LRU é Menos Usado Recentemente, o que significa que acreditamos que os dados que foram usados ​​recentemente devem ser "úteis". Os dados que não foram usados ​​por um longo tempo devem ser inúteis. Quando a memória está cheia, exclua aqueles que não foram usados ​​por muito tempo.

Pensamento de processo

Meu pensamento é o seguinte: mantemos um array, e o nó mais próximo ao final do array é acessado mais cedo. Quando um novo dado é acessado, percorremos os dados
1. Se os dados foram armazenados em cache no array antes, percorremos para obter os dados, retornar com sucesso, excluí-los da posição original e, em seguida, inseri-los no array Head.
2. Se os dados não estiverem armazenados em cache na matriz, eles podem ser divididos em duas situações:

• Se o cache não estiver cheio neste momento, insira esses dados diretamente no cabeçalho do array;
• Se o buffer estiver cheio neste momento, exclua os últimos dados do array e insira um novo nó de dados no cabeçalho do array.

alcançar

// Matriz para alcançar LRU, a eficiência geral não é alta, aqui é principalmente para saber o que a estratégia de eliminação está acontecendo

package main

import "fmt"

type cache struct {
    
    
	arr []int
	MaxLen int //缓存的最大元素个数
}


func (c *cache)Get(value int)  {
    
    
	var flag bool
	for i,v:=range c.arr{
    
    
		if v==value{
    
    
			flag=true
			//数据在第一个
			if i==0{
    
    
				return
			}else {
    
    
				c.arr[i],c.arr[0]=c.arr[0],c.arr[i]
			}
		}
	}
	if !flag{
    
    
		//当前元素不在缓存中
		if c.Length()<c.MaxLen {
    
    
			//不用淘汰，在头部添加即可
			c.Add(value)
		}else {
    
    
			// 去掉最后一个元素，然后将新元素添加到头部
			c.arr=c.arr[:c.Length()-1]
			c.Add(value)
		}
	}
}

//在头部添加一个元素
func (c *cache)Add(value int)  {
    
    
	if c.MaxLen<c.MaxLen {
    
    
		return
	}
	c.arr = append(c.arr[:0], append([]int{
    
    value}, c.arr[0:]...)...)
}

// 获取当前缓存有哪些元素
func (c *cache)ShowData()[]int  {
    
    
	return c.arr
}

func (c *cache)Append(value int)  {
    
    
	if c.Length()>=c.MaxLen {
    
    
		return
	}
	c.arr=append(c.arr,value)
}

func (c *cache)Length() int {
    
    
	return len(c.arr)
}

func NewCache(max int)*cache  {
    
    
	res:=&cache{
    
    
		MaxLen:max,
	}
	return res
}

func main()  {
    
    
	cacheDome:=NewCache(3)
	cacheDome.Append(1)
	cacheDome.Append(2)
	cacheDome.Append(3)
	fmt.Println(cacheDome.ShowData())
	cacheDome.Append(4)
	fmt.Println(cacheDome.ShowData())
	cacheDome.Get(4)
	fmt.Println(cacheDome.ShowData())
	cacheDome.Get(5)
	fmt.Println(cacheDome.ShowData())
}