Comment résoudre les problèmes de mise en cache des requêtes et de mise à jour du cache des requêtes réseau simultanées en langage Go ?

Titre : Solution au problème de demande de mise en cache et de mise à jour du cache des requêtes réseau simultanées en langage Go

Introduction :
Dans le développement de programmes modernes, les requêtes réseau sont des opérations très courantes, et les requêtes simultanées visent à améliorer les performances du programme et la vitesse de réponse est clé. Cependant, dans les requêtes réseau simultanées, des problèmes tels que des requêtes répétées et des données incohérentes sont souvent rencontrés. Cet article explique comment résoudre ces problèmes dans le langage Go en utilisant la mise en cache des requêtes et la mise à jour du cache, et fournit des exemples de code spécifiques.

1. Implémentation de la mise en cache des requêtes

1. Utilisation de sync.Map
   sync.Map dans le langage Go est un type de mappage thread-safe qui peut être utilisé comme structure de stockage pour la mise en cache des requêtes. Voici un exemple de code qui utilise sync.Map pour implémenter la mise en cache des requêtes :

package main

import (
    "fmt"
    "sync"
    "time"
)

var cache sync.Map

func fetchData(url string) string {
    // 模拟网络请求
    time.Sleep(1 * time.Second)
    return fmt.Sprintf("Data from %s", url)
}

func getData(url string) string {
    // 先从缓存中获取数据
    if data, ok := cache.Load(url); ok {
        return data.(string)
    }

    // 如果缓存中不存在，则发送网络请求获取数据，并将其存入缓存
    data := fetchData(url)
    cache.Store(url, data)
    return data
}

func main() {
    urls := []string{"https://example.com", "https://google.com", "https://example.com"}

    for _, url := range urls {
        go func(url string) {
            fmt.Println(getData(url))
        }(url)
    }

    time.Sleep(3 * time.Second)
}

La fonction getData dans le code ci-dessus utilise sync.Map pour implémenter la mise en cache des requêtes. Recherchez le cache avant chaque requête. S'il existe, renvoyez-le directement. Sinon, envoyez une requête réseau pour obtenir les données et stockez les données dans le cache. Dans l'exemple, trois URL identiques sont utilisées pour effectuer plusieurs requêtes simultanées afin de vérifier l'efficacité du cache.

2. Utiliser GoCache
   GoCache est une bibliothèque de cache mémoire basée sur l'algorithme LRU, offrant des fonctions de mise en cache pratiques et efficaces. Voici un exemple de code qui utilise GoCache pour résoudre le problème de la mise en cache des requêtes simultanées :

package main

import (
    "fmt"
    "github.com/patrickmn/go-cache"
    "net/http"
    "time"
)

var c = cache.New(5*time.Minute, 10*time.Minute)

func fetchData(url string) string {
    // 发送网络请求获取数据
    resp, err := http.Get(url)
    if err != nil {
        return ""
    }
    defer resp.Body.Close()

    // 读取响应数据
    data, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return ""
    }

    return string(data)
}

func getData(url string) string {
    // 先从缓存中获取数据
    if data, found := c.Get(url); found {
        return data.(string)
    }

    // 如果缓存中不存在，则发送网络请求获取数据，并将其存入缓存
    data := fetchData(url)
    c.Set(url, data, cache.DefaultExpiration)
    return data
}

func main() {
    urls := []string{"https://example.com", "https://google.com", "https://example.com"}

    for _, url := range urls {
        go func(url string) {
            fmt.Println(getData(url))
        }(url)
    }

    time.Sleep(3 * time.Second)
}

La fonction getData dans le code ci-dessus utilise GoCache pour implémenter le cache des requêtes simultanées. Recherchez le cache avant chaque requête. S'il existe, renvoyez-le directement. Sinon, envoyez une requête réseau pour obtenir les données et stockez les données dans le cache. Dans l'exemple, trois URL identiques sont utilisées pour effectuer plusieurs requêtes simultanées afin de vérifier l'efficacité du cache.

2. Problèmes et solutions aux mises à jour du cache
Dans les requêtes réseau simultanées, le cache doit souvent être mis à jour régulièrement pour maintenir les données à jour. Voici un exemple de code qui utilise des tâches planifiées et des verrous mutex pour résoudre le problème de mise à jour du cache :

package main

import (
    "fmt"
    "sync"
    "time"
)

var cache sync.Map
var mutex sync.Mutex

func fetchData(url string) string {
    // 模拟网络请求
    time.Sleep(1 * time.Second)
    return fmt.Sprintf("Data from %s", url)
}

func getData(url string) string {
    // 先从缓存中获取数据
    if data, ok := cache.Load(url); ok {
        return data.(string)
    }

    // 如果缓存中不存在，则发送网络请求获取数据，并将其存入缓存
    mutex.Lock()
    defer mutex.Unlock()
    if data, ok := cache.Load(url); ok {
        return data.(string)
    }

    data := fetchData(url)
    cache.Store(url, data)
    return data
}

func updateCache() {
    for {
        time.Sleep(10 * time.Second)
        
        // 清空缓存
        cache.Range(func(key, value interface{}) bool {
            cache.Delete(key)
            return true
        })
    }
}

func main() {
    go updateCache()

    urls := []string{"https://example.com", "https://google.com", "https://example.com"}

    for _, url := range urls {
        go func(url string) {
            fmt.Println(getData(url))
        }(url)
    }

    time.Sleep(30 * time.Second) // 模拟程序运行一段时间
}

La fonction getData dans le code ci-dessus utilise un verrou mutex lors de la demande pour garantir la cohérence des données du cache. Lorsque les données n'existent pas dans le cache, après l'acquisition du verrou, il est à nouveau déterminé si le cache existe déjà pour éviter des requêtes répétées. Dans le même temps, une tâche planifiée updateCache est ajoutée pour effacer les données du cache toutes les 10 secondes afin de simuler les mises à jour du cache. Dans l'exemple, trois URL identiques sont utilisées pour effectuer plusieurs requêtes simultanées afin de vérifier la validité et le mécanisme de mise à jour du cache.

Conclusion :
En utilisant la solution de mise en cache des requêtes et de mise à jour du cache, le problème des requêtes réseau simultanées peut être résolu efficacement en langage Go. Le choix d'un mécanisme de mise en cache approprié et d'une stratégie de mise à jour basée sur les besoins réels peut améliorer considérablement les performances du programme et la vitesse de réponse.

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!