并发模式的选择取决于任务性质、数据访问、同步需求和错误处理。go 中常见的并发模式包括通道（用于通信）、goroutine 池（用于管理大量 goroutine）和 waitgroup（用于确保所有 goroutine 完成后再继续执行）。另外，本文还提供了推荐系统示例，展示如何使用并发模式优化数据获取和处理过程。

Golang 函数并发编程：如何选择合适的并发模式

在 Go 中，并发是通过 goroutine（轻量级线程）和通信通道实现的。 goroutine 可以并发执行任务，但要谨慎选择适当的并发模式，以最大限度地提高性能和可维护性。

选择并发模式的因素

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

以下是选择并发模式时要考虑的关键因素：

• 任务的性质：任务是独立的还是相互依赖的？
• 数据访问：任务是否会访问共享数据？
• 同步需求：任务是否需要相互协调？
• 错误处理：并发任务失败时如何处理？

常见的并发模式

Go 中有几种常见的并发模式：

1. 通道

通道是 Go 中用于任务之间通信的结构。与管道类似，通道可以将值从一个 goroutine 传递到另一个 goroutine。

package main

import "fmt"

func main() {
    ch := make(chan int)
    go func() {
        ch <- 10
    }()
    n := <-ch
    fmt.Println(n) // 输出：10
}

2. Goroutine Pool

Goroutine 池是一种管理大量 goroutine 的有效方式。它避免了频繁创建和销毁 goroutine 的开销。

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    pool := &sync.Pool{
        New: func() interface{} {
            return &time.Timer{}
        },
    }

    t := pool.Get().(*time.Timer)
    defer pool.Put(t)

    t.Reset(1 * time.Second)
    <-t.C

    fmt.Println("Timer fired")
}

3. WaitGroup

WaitGroup 是一个计数器，它可以确保所有 goroutine 完成工作后再继续执行。

package main

import (
    "fmt"
    "sync"
    "time"
)

func main() {
    var wg sync.WaitGroup
    wg.Add(2)

    go func() {
        time.Sleep(1 * time.Second)
        fmt.Println("Goroutine 1 finished")
        wg.Done()
    }()

    go func() {
        time.Sleep(2 * time.Second)
        fmt.Println("Goroutine 2 finished")
        wg.Done()
    }()

    wg.Wait()
    fmt.Println("All goroutines finished")
}

实战案例

以下是一个推荐系统示例，展示了并发模式的实际应用：

package main

import (
    "context"
    "fmt"
    "sync"
    "time"
)

type User struct {
    ID   int64
    Name string
}

type Recommendation struct {
    UserID int64
    ItemID int64
}

// 我们假设这些函数从数据库中获取数据
func GetUsers(ctx context.Context) ([]User, error) {
    // ...
}

func GetRecommendations(ctx context.Context, users []User) ([]Recommendation, error) {
    // ...
}

func main() {
    ctx := context.Background()

    // 异步获取用户
    usersChan := make(chan []User)
    go func() {
        users, err := GetUsers(ctx)
        if err != nil {
            fmt.Println(err)
            close(usersChan)
            return
        }
        usersChan <- users
        close(usersChan)
    }()

    // 等待用户数据
    users := <-usersChan

    // 异步获取推荐项
    var mu sync.Mutex
    recommendationsChan := make(chan []Recommendation)
    for _, user := range users {
        go func(user User) {
            recommendations, err := GetRecommendations(ctx, user)
            if err != nil {
                fmt.Println(err)
                return
            }
            mu.Lock()
            recommendationsChan <- recommendations
            mu.Unlock()
        }(user)
    }

    // 聚合推荐项
    recommendations := make([]Recommendation, 0)
    for {
        select {
        case v, ok := <-recommendationsChan:
            if !ok {
                break
            }
            recommendations = append(recommendations, v...)
        case <-time.After(5 * time.Second):
            fmt.Println("Timeout")
            break
        }
    }

    // 处理所有推荐项
    fmt.Println(recommendations)
}

在这个示例中，我们使用通道来并发获取用户和推荐项。这允许我们重叠任务，从而提高吞吐量。此外，我们使用 WaitGroup 来确保所有 goroutine 完成工作后再进行后续处理。