Mécanisme de synchronisation entre la fonction golang et goroutine

Le mécanisme de synchronisation dans Go comprend : Channel : utilisé pour transférer en toute sécurité des données entre Goroutines, en bloquant les opérations d'envoi et de réception. Verrouillage mutex : assurez-vous qu'un seul Goroutine peut accéder aux ressources partagées en même temps. Groupe d'attente : suit le nombre de Goroutines en attente de fin. Ce mécanisme permet au Goroutine principal d'attendre que tous les Goroutines soient terminés avant de poursuivre l'exécution.

Mécanisme de synchronisation des fonctions et des Goroutines dans Go

Dans Go, les fonctions et les Goroutines sont des unités d'exécution concurrentes. Pour garantir la coordination et l’intégrité des données entre eux, un mécanisme de synchronisation est nécessaire. Cet article présentera les mécanismes de synchronisation couramment utilisés dans Go et fournira des cas pratiques.

Channel

Un canal est un tampon utilisé pour transférer en toute sécurité des données entre Goroutines. L'opération d'envoi du canal (ch ) et l'opération de réception (<code>v := ) sont toutes deux bloquantes. Cela signifie que l'expéditeur n'enverra des données que s'il y a de l'espace disponible dans le canal, et que le récepteur ne recevra des données que s'il y a des données disponibles dans le canal. <code>ch ）和接收操作（<code>v := ）都是阻塞的。这意味着发送方只有在通道中有可用的空间时才会发送数据，而接收方只有在通道中有可用数据时才会接收数据。

实战案例：使用通道在多个 Goroutine 之间传递数据

package main

import "fmt"

func main() {
    // 创建一个带有缓冲区的通道（可以存储最多 10 个值）
    ch := make(chan int, 10)

    // 启动 5 个 Goroutine 向通道发送数据
    for i := 0; i < 5; i++ {
        go func(i int) {
            ch <- i
        }(i)
    }

    // 从通道接收数据并打印结果
    for i := 0; i < 5; i++ {
        fmt.Println(<-ch)
    }
}

互斥锁 (Mutex)

互斥锁是一种低级的同步机制，用于确保同一时间只有一个 Goroutine 可以访问共享资源。sync.Mutex 类型提供了对互斥锁的访问。

实战案例：使用互斥锁保护对共享资源的访问

package main

import (
    "fmt"
    "sync"
)

var (
    mu      sync.Mutex // 定义一个互斥锁
    counter int       // 共享资源
)

func main() {
    for i := 0; i < 100; i++ {
        go func(i int) {
            // 获取互斥锁
            mu.Lock()
            defer mu.Unlock() // 释放互斥锁

            // 访问共享资源
            counter++
            fmt.Printf("Goroutine %d: counter = %d\n", i, counter)
        }(i)
    }
}

等待组 (WaitGroup)

等待组用于跟踪正在等待完成的 Goroutine 的数量。当 Goroutine 完成时，它们调用 Done 方法来减少等待组计数。主 Goroutine可以通过调用 Wait

Cas pratique : Utiliser des canaux pour transférer des données entre plusieurs Goroutines

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    // 启动 5 个 Goroutine
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go func(i int) {
            fmt.Printf("Goroutine %d started\n", i)
            defer wg.Done() // Goroutine 完成时调用 Done
        }(i)
    }

    // 等待所有 Goroutine 完成
    wg.Wait()
    fmt.Println("All Goroutines finished")
}

Mutex (Mutex)

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!