Quels sont les mécanismes de synchronisation entre les fonctions golang et goroutine ?

Le langage Go fournit une variété de mécanismes de synchronisation, notamment des verrous mutex, des verrous en lecture-écriture, des variables de condition et WaitGroup, pour résoudre les incohérences de données ou les conditions de concurrence provoquées par l'accès simultané aux ressources partagées. Les verrous Mutex fournissent un accès exclusif aux ressources partagées, les verrous en lecture-écriture prennent en charge plusieurs lectures simultanées et écritures uniques, les variables de condition sont utilisées pour coordonner l'attente et la notification entre les Goroutines, et WaitGroup est utilisé pour attendre la fin d'un groupe de Goroutines. Par exemple, dans le cas d'un tampon partagé, un mutex peut garantir qu'un seul Goroutine accède au tampon à la fois, évitant ainsi la corruption des données.

Mécanisme de synchronisation des fonctions et des Goroutines en langage Go

En programmation simultanée, le mécanisme de synchronisation est crucial pour garantir que l'accès simultané aux ressources partagées n'entraîne pas d'incohérence des données ou de conditions de concurrence. Le langage Go fournit une variété de mécanismes de synchronisation. Voici les mécanismes les plus couramment utilisés pour la synchronisation des fonctions et Goroutine :

Mutex (Mutex)

Mutex fournit un accès exclusif aux ressources partagées. Lorsqu'un Goroutine acquiert un mutex, les autres Goroutines seront bloquées jusqu'à ce que le Goroutine libère le mutex.

var mu sync.Mutex

func someFunction() {
    mu.Lock()
    // 对共享资源进行操作
    mu.Unlock()
}

Verrouillage en lecture-écriture (RWMutex)

Le verrouillage en lecture-écriture permet à plusieurs Goroutines de lire les ressources partagées en même temps, mais un seul Goroutine peut écrire sur des ressources partagées en même temps.

var rwmu sync.RWMutex

func someFunction() {
    rwmu.RLock()
    // 读取共享资源
    rwmu.RUnlock()
}

func anotherFunction() {
    rwmu.Lock()
    // 写入共享资源
    rwmu.Unlock()
}

Variable de condition (Cond)

La variable de condition est utilisée pour coordonner l'attente et la notification entre les Goroutines. Un Goroutine peut attendre une variable de condition jusqu'à ce qu'un autre Goroutine la notifie.

var cond sync.Cond

func someFunction() {
    cond.L.Lock()
    // 等待条件变量被通知
    cond.Wait(&cond.L)
    // 执行被通知后的代码
    cond.L.Unlock()
}

func anotherFunction() {
    cond.L.Lock()
    // 通知正在等待条件变量的 Goroutine
    cond.Signal()
    cond.L.Unlock()
}

WaitGroup

WaitGroup est utilisé pour attendre qu'un groupe de Goroutines se termine. Il garantit que certaines opérations ne sont pas effectuées tant que tous les Goroutines ne sont pas terminés.

var wg sync.WaitGroup

func someFunction() {
    wg.Add(1)

    // Goroutine 执行一些任务

    wg.Done()
}

func main() {
    wg.Add(5)

    for i := 0; i < 5; i++ {
        go someFunction()
    }

    // 等待所有 Goroutine 完成
    wg.Wait()

    // 主 Goroutine 执行一些操作
}

Cas pratique

Prenons un tampon partagé comme exemple. Plusieurs Goroutines lisent et écrivent des données à partir du tampon. Nous pouvons utiliser un mutex pour garantir un accès simultané au tampon :

var mu sync.Mutex
type Buffer struct {
    data []int
}

func (b *Buffer) Read() []int {
    mu.Lock()
    defer mu.Unlock()

    return b.data
}

func (b *Buffer) Write(data []int) {
    mu.Lock()
    defer mu.Unlock()

    b.data = data
}

En utilisant un mutex, nous garantissons qu'un seul Goroutine peut accéder au tampon partagé à un moment donné, évitant ainsi la corruption des données.

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!