Synchronization mechanism between golang function and goroutine

The synchronization mechanism in Go includes: Channel: used to safely transfer data between Goroutines, using blocking send and receive operations. Mutex lock: Ensure that only one Goroutine can access shared resources at the same time. Waiting group: Tracks the number of Goroutines waiting to complete. This mechanism allows the main Goroutine to wait for all Goroutines to complete before continuing execution.

Synchronization mechanism of functions and Goroutines in Go

In Go, functions and Goroutines are concurrent execution units. To ensure coordination and data integrity between them, a synchronization mechanism is required. This article will introduce the commonly used synchronization mechanisms in Go and provide practical cases.

Channel

A channel is a buffer used to safely transfer data between Goroutines. The channel's send operation (ch ) and receive operation (<code>v := ) are both blocking. This means that the sender will only send data if there is space available in the channel, and the receiver will only receive data if there is data available in the channel.

Practical case: Using channels to transfer data between multiple Goroutines

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 (Mutex)

Mutex is a low-level synchronization mechanism used to ensure that only one Goroutine can access shared resources at the same time. The sync.Mutex type provides access to mutex locks.

Practical case: Using mutex locks to protect access to shared resources

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

Waiting group (WaitGroup)

Waiting Groups are used to track the number of Goroutines waiting to complete. When Goroutines complete, they call the Done method to decrement the wait group count. The main Goroutine can block until all Goroutines complete by calling the Wait method.

Practical case: Use waiting group to wait for all Goroutines to complete

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")
}

It is crucial to understand the synchronization mechanism

Choose the right one Synchronization mechanisms are crucial to building robust and correct Go programs in a concurrent environment. By understanding the use of channels, mutexes, and wait groups, you can ensure coordination and data consistency between functions and Goroutines.

The above is the detailed content of Synchronization mechanism between golang function and goroutine. For more information, please follow other related articles on the PHP Chinese website!