golang函数与goroutine的同步机制

Go 中的同步机制包括：通道：用于在 Goroutine 之间安全地传递数据，采用阻塞式发送和接收操作。互斥锁：确保同一时间只有一个 Goroutine 可以访问共享资源。等待组：跟踪正在等待完成的 Goroutine 数量，主 Goroutine 可通过该机制等待所有 Goroutine 完成再继续执行。

Go 中函数和 Goroutine 的同步机制

在 Go 中，函数和 Goroutine 是并发的执行单元。为了确保它们之间的协调和数据完整性，需要使用同步机制。本文将介绍 Go 中常用的同步机制，并提供实战案例。

通道 (Channel)

通道是一种用于在 Goroutine 之间安全地传递数据的缓冲区。通道的发送操作（ch <- v）和接收操作（v := <-ch）都是阻塞的。这意味着发送方只有在通道中有可用的空间时才会发送数据，而接收方只有在通道中有可用数据时才会接收数据。

实战案例：使用通道在多个 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 方法来阻塞，直到所有 Goroutine 完成。

实战案例：使用等待组等待所有 Goroutine 完成

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

理解同步机制至关重要

选择正确的同步机制对于在并发环境中构建健壮且正确的 Go 程序至关重要。通过了解通道、互斥锁和等待组的使用，可以确保函数和 Goroutine 之间的协调和数据一致性。