go 函数并发编程的重构建议：使用 goroutine 池以防止创建和销毁 goroutine 的开销。避免在并发函数中返回指针，以防止外部函数修改内部状态。小心使用闭包，以避免意外的数据共享。使用通道通信，以安全有效地进行 goroutine 之间的通信。使用 waitgroup 跟踪并发任务的完成情况，确保在 wait 方法调用之前所有任务都已完成。

Go 函数并发编程的代码重构建议

在 Go 中，函数并发编程是一个强大的工具，可以提高代码的速度和可扩展性。但是，在编写并发代码时，遵循最佳实践以确保代码的可读性和可维护性非常重要。本文介绍了重构 Go 函数并发代码的五个建议，以及每个建议的实战示例。

1. 使用 goroutine 池

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

goroutine 池可以防止创建和销毁 goroutine 的开销。以下是如何使用 sync.Pool 创建 goroutine 池：

import "sync"

var pool = sync.Pool{
    New: func() interface{} {
        return new(sync.Mutex)
    },
}

func getMutexFromPool() *sync.Mutex {
    return pool.Get().(*sync.Mutex)
}

func putMutexBackToPool(m *sync.Mutex) {
    pool.Put(m)
}

2. 避免在并发函数中返回指针

返回指针允许外部函数修改并发函数内部状态，这可能会导致数据竞争。相反，请返回值的副本：

// 错误示例：返回指针
func getProtectedCounterPtr() *int {
    return &counter
}

// 正确示例：返回值的副本
func getProtectedCounter() int {
    return counter
}

3. 小心使用闭包

闭包会捕获传入并发函数的变量，这可能会导致意外的数据共享。使用局部变量或互斥锁来保护共享数据：

// 错误示例：闭包会捕获变量
func runConcurrentTasks(tasks []func()) {
    for _, task := range tasks {
        go func() {
            task()
        }()
    }
}

// 正确示例：使用局部变量
func runConcurrentTasks(tasks []func()) {
    for _, task := range tasks {
        go func(task func()) {
            task()
        }(task)
    }
}

4. 使用通道通信

通道是 goroutine 之间通信的安全且高效的方式。避免直接访问共享内存：

// 错误示例：直接访问共享内存
var counter int

func incrementCounter() {
    counter++
}

func getCounter() int {
    return counter
}

// 正确示例：使用通道通信
var counterChan = make(chan int)

func incrementCounter() {
    counterChan <- counter + 1
}

func getCounter() int {
    return <-counterChan
}

5. 使用 waitgroup 等待并发任务完成

WaitGroup 可以跟踪并发任务的完成情况，确保在调用 wait 方法之前所有任务都已完成。

var wg sync.WaitGroup

func doWork(i int) {
    defer wg.Done()
    // Do some work
}

func main() {
    for i := 0; i < 10; i++ {
        wg.Add(1)
        go doWork(i)
    }
    wg.Wait()
}