Analyse de document en langage Go : la fonction sync.Once implémente une exécution unique

Analyse de document en langage Go : la fonction sync.Once implémente une exécution unique et nécessite des exemples de code spécifiques

Le package sync du langage Go fournit certaines fonctions et types pour les opérations synchrones. Une fonction très utile est sync.Once, qui garantit qu'une opération n'est effectuée qu'une seule fois. Dans cet article, nous analyserons en détail l’utilisation de la fonction sync.Once et fournirons quelques exemples de code spécifiques. La fonction

sync.Once est définie comme suit :

type Once struct {
    m    Mutex
    done uint32
}

func (o *Once) Do(f func()) {
    if atomic.LoadUint32(&o.done) == 1 {
        return
    }
    o.m.Lock()
    defer o.m.Unlock()
    if o.done == 0 {
        f()
        atomic.StoreUint32(&o.done, 1)
    }
}

Comme vous pouvez le voir, la structure sync.Once contient un mutex (Mutex) et un indicateur done pour enregistrer si l'opération a été exécutée. La méthode Do de la structure Once est la logique de base pour réaliser une exécution unique.

La méthode Do vérifie d'abord si l'indicateur terminé est 1 via l'opération atomique atomic.LoadUint32. S'il vaut 1, cela signifie que l'opération a été effectuée et revient directement. Sinon, acquérez le mutex et vérifiez à nouveau si l'indicateur terminé est 0. S'il est égal à 0, la fonction transmise f est exécutée et l'indicateur terminé est défini sur 1 via l'opération atomique atomic.StoreUint32 pour garantir que f ne sera pas exécuté lors de son prochain appel.

Voici un exemple simple qui montre comment utiliser la fonction sync.Once pour réaliser une seule exécution :

package main

import (
    "fmt"
    "sync"
)

var once sync.Once

func main() {
    for i := 0; i < 5; i++ {
        // 只有第一次调用会执行
        once.Do(func() {
            fmt.Println("This will only print once.")
        })
    }
}

Exécutez le code ci-dessus et le résultat est le suivant :

This will only print once.

Vous pouvez le voir bien que once.Do soit appelé plusieurs fois dans la méthode de boucle, mais en fait, seul le premier appel exécutera la fonction transmise, et les appels suivants reviendront directement sans l'exécuter à nouveau.

Les scénarios d'utilisation de la fonction sync.Once sont très larges. Par exemple, lors de l'initialisation d'une variable globale, nous souhaitons généralement effectuer l'initialisation une seule fois, plutôt que de l'initialiser à chaque accès à la variable. À ce stade, vous pouvez utiliser la fonction sync.Once pour vous assurer que l'initialisation n'est effectuée qu'une seule fois.

var (
    data  []string
    once  sync.Once
)

func loadData() {
    // 模拟耗时的数据加载操作
    // 这里简单起见直接赋值
    data = []string{"Hello", "World"}
}

func getData() []string {
    once.Do(loadData)
    return data
}

func main() {
    fmt.Println(getData())
    fmt.Println(getData())
}

Exécutez le code ci-dessus et le résultat de sortie est le suivant :

[Hello World]
[Hello World]

En utilisant la fonction sync.Once et la fonction loadData ensemble, nous nous assurons que la variable data ne sera initialisée que lorsque la fonction getData est appelée pour la première fois. heure, et les appels suivants le renverront directement les données initialisées.

Résumé : 

La fonction sync.Once est l'une des fonctions importantes du langage Go pour réaliser une exécution unique. Il utilise des verrous mutex et des opérations atomiques pour garantir qu'une opération n'est exécutée qu'une seule fois, ce qui est très pratique et efficace. Dans le développement réel, nous pouvons utiliser pleinement la fonction sync.Once pour optimiser la logique du code, éviter les exécutions répétées qui affectent les performances et garantir l'unicité des opérations.

Grâce à l'analyse et à l'exemple de code de cet article, je pense que les lecteurs peuvent maîtriser l'utilisation de la fonction sync.Once et pouvoir l'utiliser de manière flexible dans des projets réels. Travaillons ensemble pour écrire des programmes de langue Go de meilleure qualité !

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!