并发模式的选择取决于任务性质、数据访问、同步需求和错误处理。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 完成工作后再进行后续处理。
