go语言函数并发通信模式：通道（channel）： 无缓冲管道，用于在 goroutine 之间传递数据。mutex（互斥锁）： 用于同步对共享资源的访问，确保一次只有一个 goroutine 可访问。等待组（wait group）： 用于等待一组 goroutine 完成，当所有 goroutine 完成后变为已完成。

Go 语言函数并发编程中的通信模式

在 Go 语言中，通过并发编程可以提高应用程序的性能和可扩展性。而函数并发编程是其中一种常用的技术，它允许在一个函数中并发执行多个任务。为了在并发函数之间进行通信，我们需要使用特定的通信模式。

通道（Channel）

立即学习“go语言免费学习笔记（深入）”；

通道是 Go 语言中用于在并发函数之间传递数据的无缓冲管道。我们可以在不同的 Goroutine 中使用通道作为参数，以便在这些 Goroutine 之间安全地传递值。

Golang Uber Dig

使用 uber-go/dig 在 Golang 中实现依赖注入——基于反射容器，提供 Provide/Invoke、dig.In/dig.Out 参数与结果对象，支持命名依赖等

下载

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup
    ch := make(chan int)

    // 发送者 Goroutine
    wg.Add(1)
    go func() {
        defer wg.Done()
        ch <- 42
    }()

    // 接收者 Goroutine
    wg.Add(1)
    go func() {
        defer wg.Done()
        v := <-ch
        fmt.Println(v)
    }()

    wg.Wait()
}

Mutex

Mutex（互斥锁）用于同步对共享资源的访问。通过对临界区进行加锁，可以确保一次只有一个 Goroutine可以访问该资源。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var count int
    var mu sync.Mutex

    // 多个 Goroutine 并发更新共享变量
    for i := 0; i < 1000; i++ {
        go func() {
            mu.Lock()
            count++
            mu.Unlock()
        }()
    }

    // 等待所有 Goroutine 完成
    for {
        mu.Lock()
        if count == 1000 {
            mu.Unlock()
            break
        }
        mu.Unlock()
    }

    fmt.Printf("最终计数：%d\n", count)
}

等待组（Wait Group）

等待组用于等待一组 Goroutine 完成。当所有 Goroutine 完成后，等待组会将状态变为已完成。

package main

import (
    "fmt"
    "sync"
)

func main() {
    var wg sync.WaitGroup

    // 创建 10 个 Goroutine
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go func(i int) {
            defer wg.Done()
            fmt.Printf("Goroutine %d 完成\n", i)
        }(i)
    }

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

    fmt.Println("所有 Goroutine 完成")
}

通过合理使用这些通信模式，我们可以有效地实现 Go 语言函数并发编程，提高应用程序的并发性并避免数据竞争问题。