Comment utiliser Golang pour implémenter la mise en cache du serveur Web

Avec le développement d'Internet, la mise en cache des serveurs Web est devenue l'un des moyens importants pour améliorer les performances des applications Web. Dans le développement précédent, nous utilisions principalement des middlewares de mise en cache spécialisés tels que Memcached et Redis. Cependant, nous pouvons désormais utiliser la propre bibliothèque de concurrence de Golang pour implémenter la mise en cache du serveur Web afin de résoudre les problèmes de performances de certaines applications à petite échelle. Cet article se concentrera sur la façon d'utiliser Golang pour implémenter la mise en cache du serveur Web.

1. Bibliothèques de concurrence couramment utilisées dans Golang

Golang possède une richesse de bibliothèques de concurrence, notamment de synchronisation, de canal, de contexte et d'autres bibliothèques couramment utilisées. Parmi eux, les plus couramment utilisés sont Mutex et RWMutex fournis dans la bibliothèque de synchronisation. Mutex est le type de verrou le plus basique, qui ne peut être détenu que par un seul goroutine à la fois. Son utilisation peut garantir la sécurité de plusieurs goroutines accédant simultanément aux ressources partagées. RWMutex est un verrou en lecture-écriture basé sur Mutex, qui peut limiter le nombre de goroutines lisant les ressources en même temps et améliorer l'efficacité de la lecture simultanée.

2. Étapes pour mettre en œuvre la mise en cache du serveur Web

Ci-dessous, nous suivrons les étapes suivantes pour mettre en œuvre la mise en cache du serveur Web :

# 🎜 🎜#2.1 Créer une structure de cache

Nous pouvons utiliser RWMutex dans la bibliothèque de synchronisation pour implémenter une structure de cache simultanément sécurisée, dans laquelle la carte est utilisée comme structure de stockage de cache. L'implémentation spécifique est la suivante :

type Cache struct {
    cache map[string]interface{}
    rw    sync.RWMutex
}

func NewCache() *Cache {
    return &Cache{
        cache: make(map[string]interface{}),
    }
}

2.2 Implémentation des fonctions d'opération de cache

Implémenter les fonctions d'opération de base du cache, telles que Get, Set, Supprimer, etc. Parmi eux, nous utilisons RWMutex pour assurer la sécurité des accès simultanés au cache.

func (c *Cache) Get(key string) (interface{}, bool) {
    c.rw.RLock()
    defer c.rw.RUnlock()
    item, ok := c.cache[key]
    return item, ok
}

func (c *Cache) Set(key string, value interface{}) {
    c.rw.Lock()
    defer c.rw.Unlock()
    c.cache[key] = value
}

func (c *Cache) Delete(key string) {
    c.rw.Lock()
    defer c.rw.Unlock()
    delete(c.cache, key)
}

2.3 Traitement d'expiration du cache

Les données dans le cache ont différentes durées d'existence Nous pouvons définir la durée du cache pour garantir la fraîcheur des données mises en cache en les supprimant régulièrement. . Pour ce faire, nous devons utiliser goroutine pour supprimer périodiquement les données de cache expirées.

func (c *Cache) deleteExpired() {
    for {
        time.Sleep(time.Second * 30)

        c.rw.Lock()
        for key, value := range c.cache {
            item, ok := value.(*item)
            if ok && item.expired.Before(time.Now()) {
                delete(c.cache, key)
            }
        }
        c.rw.Unlock()
    }
}

type item struct {
    data    interface{}
    expired time.Time
}

func (c *Cache) SetWithExpiration(key string, value interface{}, expiration time.Duration) {
    item := &item{
        data:    value,
        expired: time.Now().Add(expiration),
    }
    c.rw.Lock()
    defer c.rw.Unlock()
    c.cache[key] = item
}

func NewCache() *Cache {
    c := &Cache{
        cache: make(map[string]interface{}),
    }
    go c.deleteExpired()
    return c
}

Summary

Cet article explique comment utiliser la propre bibliothèque de concurrence de Golang pour implémenter la mise en cache du serveur Web. En implémentant les fonctions opérationnelles de base du cache et de la goroutine qui suppriment périodiquement les données mises en cache expirées, nous pouvons créer nous-mêmes un cache de serveur Web léger pour résoudre les problèmes de performances des applications à petite échelle. Dans le même temps, nous pouvons également apprendre les méthodes de base d'utilisation de la bibliothèque de concurrence Golang, ce qui nous aidera à mieux exploiter les avantages de Golang en matière de performances de concurrence dans les développements futurs.

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!