Application pratique de la technologie de mise en cache et de planification des tâches dans Golang.

Application pratique de la technologie de mise en cache et de planification des tâches dans Golang

Depuis sa création en 2009, le langage Golang est devenu un langage de programmation couramment utilisé dans le cloud computing, le big data, la blockchain et d'autres domaines. Parmi eux, le mécanisme de haute concurrence, de coroutine et de garbage collection du langage Golang est considéré comme ses avantages uniques.

Dans les applications pratiques, la technologie de mise en cache et la planification des tâches sont des moyens techniques couramment utilisés. Cet article présentera l'application pratique de la technologie de mise en cache et de planification des tâches en langage Golang.

1. Technologie de mise en cache

La technologie de mise en cache fait référence au stockage des données couramment utilisées en mémoire pour réduire la fréquence des opérations d'E/S du système et ainsi améliorer la vitesse de réponse du système. Le langage Golang est livré avec la bibliothèque de cache mémoire sync.Map.

sync.Map est une structure de stockage clé-valeur simultanément sécurisée qui ne provoquera pas de conditions de concurrence lorsque plusieurs coroutines simultanées liront et écriront. Sa conception est relativement intelligente et peut améliorer efficacement l'efficacité de l'accès simultané.

Ce qui suit est une implémentation simple du cache :

package main

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

type cache struct {
    sync.Map
}

func main() {
    c := &cache{}
    
    c.SetCache("key1", "value1", 3*time.Second) //3秒后过期
    fmt.Println(c.GetCache("key1")) //value1
    
    time.Sleep(2*time.Second)
    fmt.Println(c.GetCache("key1")) //value1
    
    time.Sleep(2*time.Second)
    fmt.Println(c.GetCache("key1")) //nil
}

func (c *cache) SetCache(key string, value interface{}, ttl time.Duration) {
    c.Store(key, &item{
        CreateAt: time.Now(),
        ExpireAt: time.Now().Add(ttl),
        Value:    value,
    })
}

func (c *cache) GetCache(key string) interface{} {
    if v, ok := c.Load(key); ok {
        item := v.(*item)
        if item.ExpireAt.Before(time.Now()) {
            c.Delete(key)
            return nil
        }
        return item.Value
    }
    return nil
}

type item struct {
    CreateAt time.Time
    ExpireAt time.Time
    Value    interface{}
}

Dans le code ci-dessus, les paires clé-valeur mises en cache sont enregistrées sous la forme d'une structure d'éléments, où CreateAt représente l'heure à laquelle les données mises en cache sont créées, ExpireAt représente l'expiration l’heure des données mises en cache et Value représente le contenu spécifique du cache. Lorsque le délai d'expiration est atteint, le cache sera supprimé.

2. Planification des tâches

La planification des tâches fait référence à l'attribution de tâches à différentes coroutines pour exécution selon certaines règles, intervalles de temps ou règles de déclenchement d'événements. Le langage Golang fournit des fonctions de planification planifiée et d'annulation de tâches via le package de temps et le package de contexte.

Ce qui suit est une implémentation simple de planification de tâches :

package main

import (
    "context"
    "fmt"
    "time"
)

func main() {
    ctx, cancel := context.WithCancel(context.Background())
    go schedule(ctx)

    time.Sleep(10 * time.Second)
    cancel()
}

func schedule(ctx context.Context) {
    ticker := time.NewTicker(1 * time.Second)
    defer ticker.Stop()

    for {
        select {
        case <-ticker.C:
            fmt.Println("execute some job")
        case <-ctx.Done():
            fmt.Println("cancel all jobs")
            return
        }
    }
}

Dans le code ci-dessus, le minuteur exécute la tâche toutes les secondes. Lorsque Cancel() est appelé, la tâche sera annulée. Dans les applications pratiques, il peut être ajusté en fonction de besoins spécifiques.

3. Conclusion

Cet article présente l'application pratique de la technologie de mise en cache et de planification des tâches dans le langage Golang, qui peut améliorer efficacement la vitesse de réponse et l'efficacité de fonctionnement du système. Dans des applications pratiques, il peut également être combiné avec la programmation réseau, les opérations de bases de données et d'autres moyens techniques pour construire un système distribué hautes performances.

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!