Maison > développement back-end > Golang > 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.

王林
Libérer: 2023-06-21 13:44:39
original
1642 Les gens l'ont consulté

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 :

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

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{}

}

Copier après la connexion

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é.

  1. 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 :

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

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

        }

    }

}

Copier après la connexion

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.

  1. 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!

Étiquettes associées:
source:php.cn
Déclaration de ce site Web
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn
Tutoriels populaires
Plus>
Derniers téléchargements
Plus>
effets Web
Code source du site Web
Matériel du site Web
Modèle frontal