Mécanisme de sécurité et de synchronisation des fonctions Golang dans un environnement concurrent

Sécurité des fonctions : sécurité des goroutines : elle peut être appelée en toute sécurité dans des goroutines simultanées. Sécurité non goroutine : accéder à un état partagé ou s'appuyer sur une goroutine spécifique. Mécanisme de synchronisation : Mutex : protège les accès concurrents aux ressources partagées. RWMutex : permet une lecture simultanée et une seule écriture. Cond : Attendez que des conditions spécifiques soient remplies. WaitGroup : attendez la fin d'un groupe de goroutines. Cas pratique : le compteur de concurrence utilise Mutex pour protéger l'état partagé et garantir l'exactitude en cas de concurrence.

Le mécanisme de sécurité et de synchronisation de Go fonctionne dans un environnement concurrent

Dans l'environnement concurrent de Go, il est crucial de comprendre la sécurité des fonctions et le mécanisme de synchronisation correct. Cet article explorera ces concepts et les démontrera à travers un cas pratique.

Sécurité des fonctions

• sécurité des goroutines : Une fonction est dite sûre pour les goroutines si elle peut être appelée en toute sécurité à partir de goroutines simultanées. Cela signifie qu'il ne modifie pas les variables globales ou l'état partagé, et qu'il n'entre pas en concurrence avec les autres goroutines.
• Non sécurisé par goroutine : Une fonction n'est pas sécurisée par goroutine si elle accède ou modifie l'état partagé, ou s'appuie sur l'exécution d'une goroutine spécifique.

Mécanisme de synchronisation

Afin d'assurer la cohérence des données et d'éviter la concurrence dans un environnement concurrent, un mécanisme de synchronisation doit être utilisé. Go propose plusieurs types de synchronisation intégrés :

• Mutex : Mutex, utilisé pour protéger l'accès simultané aux ressources partagées.
• RWMutex : Mutex en lecture-écriture, permettant une lecture simultanée mais uniquement une écriture à la fois.
• Cond : Variable de condition, utilisée pour attendre que des conditions spécifiques soient remplies.
• WaitGroup : Groupe d'attente, utilisé pour attendre qu'un groupe de goroutines se termine.

Cas pratique : compteur de concurrence

Prenons un exemple de compteur de concurrence. Il s'agit d'une valeur stockée dans une variable sécurisée goroutine qui peut être incrémentée en parallèle. Afin de garantir l'exactitude du compteur en cas de concurrence, un mécanisme de synchronisation doit être utilisé.

package main

import (
    "fmt"
    "sync"
    "sync/atomic"
)

var (
    cnt int64        // 原子计数器
    mu sync.Mutex   // 互斥锁
)

func main() {
    wg := &sync.WaitGroup{}

    // 并发增量计数器
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func() {
            mu.Lock()
            cnt++
            mu.Unlock()
            wg.Done()
        }()
    }

    wg.Wait()
    fmt.Println("最终计数：", cnt)
}

Dans cet exemple, nous avons un accès simultané au compteur cnt 声明为原子变量以确保并发的安全增量。使用 mutex mu 来保护对 cnt pour éviter les conditions de course.

L'exécution de ce programme affichera :

最终计数： 10

Cela confirme que le compteur est correctement incrémenté 10 fois en parallèle.

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!