Implémentez une stratégie d'élimination du cache basée sur les priorités dans Golang.

Avec le développement continu de la technologie Internet, la mise en cache est devenue l'une de ses technologies clés. La mise en cache peut considérablement améliorer la vitesse d'accès des utilisateurs et réduire la pression de charge sur le serveur, et l'élimination du cache est une partie essentielle du système de mise en cache. Dans cet article, nous présenterons comment implémenter une stratégie d'expulsion de cache basée sur les priorités dans Golang.

1. Qu'est-ce que la stratégie d'élimination du cache ?

L'élimination du cache signifie que lorsque le cache est plein, certaines données du cache doivent être effacées selon certaines règles afin de stocker de nouvelles données dans le cache. Différentes stratégies d'élimination du cache ont des règles différentes, telles que FIFO (premier entré, premier sorti), LRU (le moins récemment utilisé), LFU (le moins récemment utilisé), un algorithme aléatoire, etc.

2. Implémentation dans Golang

La carte dans Golang peut être facilement utilisée pour implémenter la mise en cache. Ce qui suit est une brève introduction sur la façon d'utiliser map pour implémenter la stratégie d'élimination du cache dans Golang.

1. FIFO

FIFO est la stratégie d'élimination du cache la plus simple, qui efface les données une par une dans l'ordre dans lequel les données entrent dans le cache. Dans Golang, nous pouvons utiliser map et list pour implémenter FIFO. La carte est utilisée pour stocker les données mises en cache et la liste est utilisée pour stocker l'ordre d'insertion des données. Lorsque le cache est plein, nous trouvons les premières données insérées dans la liste et les effaçons de la carte et de la liste.

2. LRU

LRU est une stratégie d'éviction de cache basée sur le principe le moins récemment utilisé, qui est généralement considéré comme une stratégie relativement optimale. Dans Golang, nous pouvons également utiliser une carte et une liste (ou liste) doublement chaînée pour implémenter LRU. La carte est utilisée pour stocker les données mises en cache et les listes doublement liées sont utilisées pour maintenir l'ordre dans lequel les données mises en cache sont utilisées. Lorsqu'une donnée mise en cache est utilisée, nous la déplaçons en tête de la liste chaînée. Lorsque le cache est plein, nous trouvons les données inutilisées les plus anciennes via la queue de la liste chaînée et les effaçons de la carte et de la liste chaînée.

3. LFU

LFU est une stratégie d'élimination du cache basée sur le principe du moins utilisé, qui peut être plus appropriée que LRU dans certains scénarios. Dans Golang, nous pouvons également utiliser map et heap pour implémenter LFU. La carte est utilisée pour stocker les données du cache et le tas est utilisé pour conserver les données du cache triées par utilisation. Lorsqu'une certaine donnée mise en cache est utilisée, nous ajustons (ou réinsérons) son nœud dans le tas à l'emplacement du nouveau décompte d'utilisation. Lorsque le cache est plein, nous trouvons les données les moins utilisées du tas et les effaçons de la carte et du tas.

3. Stratégie d'élimination du cache basée sur les priorités

En plus des stratégies d'élimination du cache courantes présentées ci-dessus, les stratégies d'élimination du cache peuvent également être personnalisées en fonction de scénarios commerciaux. Par exemple, dans certains scénarios, nous devons décider quelles données doivent être conservées en premier en fonction d’une certaine priorité. Alors comment l’implémenter dans Golang ?

La stratégie d'expulsion du cache basée sur les priorités peut être mise en œuvre en combinant carte et tas. La carte est utilisée pour stocker les données mises en cache et le tas est utilisé pour conserver les données mises en cache triées par priorité. Afin de mettre en œuvre une stratégie d'élimination du cache basée sur les priorités, nous devons définir une priorité pour chaque donnée mise en cache. Ceci peut être réalisé en ajoutant un attribut de priorité aux données mises en cache, ou en les encapsulant dans une structure et en ajoutant un champ de priorité.

Voici un exemple de code :

type CacheItem struct {
    Key       string
    Value     interface{}
    Priority  int64 // 优先级
    Timestamp int64
}

type PriorityQueue []*CacheItem

func (pq PriorityQueue) Len() int { return len(pq) }

func (pq PriorityQueue) Less(i, j int) bool {
    return pq[i].Priority > pq[j].Priority
}

func (pq PriorityQueue) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueue) Push(x interface{}) {
    item := x.(*CacheItem)
    *pq = append(*pq, item)
}

func (pq *PriorityQueue) Pop() interface{} {
    old := *pq
    n := len(old)
    item := old[n-1]
    *pq = old[0 : n-1]
    return item
}

type Cache struct {
    data     map[string]*CacheItem
    priority *PriorityQueue
    cap      int
    expire   time.Duration // 过期时间
}

Dans le code ci-dessus, nous définissons un CacheItem et un PriorityQueue. CacheItem représente un élément de données dans le cache, qui comprend quatre attributs : clé, valeur, priorité et horodatage. PriorityQueue est une structure qui implémente l'interface heap.Interface et est utilisée pour maintenir les données du cache triées par priorité.

Ensuite, nous définissons une structure Cache, qui contient plusieurs attributs tels que les données, la priorité, le plafond, l'expiration, etc. data est utilisé pour stocker les données mises en cache, la priorité est utilisée pour maintenir la priorité des données, cap représente la capacité du cache et expire représente le délai d'expiration des données mises en cache.

Ce qui suit est un exemple de code pour éliminer les données mises en cache en fonction de la priorité :

func (cache *Cache) Set(key string, value interface{}, priority int64) {
    item := &CacheItem{
        Key:      key,
        Value:    value,
        Priority: priority,
        Timestamp: time.Now().UnixNano(),
    }
    cache.data[key] = item
    heap.Push(cache.priority, item)

    // 进行缓存淘汰
    if len(cache.data) > cache.cap {
        for {
            item := heap.Pop(cache.priority).(*CacheItem)
            if _, ok := cache.data[item.Key]; ok {
                delete(cache.data, item.Key)
                break
            }
        }
    }
}

func (cache *Cache) Get(key string) interface{} {
    item, ok := cache.data[key]
    if !ok {
        return nil
    }
    // 更新优先级
    item.Priority += 1
    item.Timestamp = time.Now().UnixNano()
    heap.Fix(cache.priority, item.Index)
    return item.Value
}

Dans la méthode Set, nous insérons les données mises en cache dans la carte et la priorité tout en effectuant l'élimination du cache. Lorsque le cache est plein, nous trouvons les données de priorité la plus basse via heap.Pop et les effaçons de la carte et de la priorité.

Dans la méthode Get, nous retrouvons les données via la carte, augmentons leur priorité de 1 et mettons à jour leur Timestamp en même temps. Ensuite, on ajuste sa position en priorité via heap.Fix.

IV. Résumé

Cet article présente la mise en œuvre de trois stratégies d'élimination de cache courantes (FIFO, LRU, LFU) dans Golang, ainsi qu'un exemple de code pour une stratégie d'élimination de cache basée sur les priorités. Dans les scénarios réels, différentes stratégies de mise en cache conviennent à différents scénarios d'application et doivent être sélectionnées en fonction des besoins de l'entreprise. Dans le même temps, certains détails doivent être pris en compte lors de l'utilisation du cache, tels que la capacité du cache et le délai d'expiration.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!