在 Go 语言中，并发编程是其核心特性之一，通过 Goroutine 和通道（Channel）可以实现多种高效的并发模式。下面为你详细介绍几种常见的并发模式。 ### 生产者 - 消费者模式生产者 - 消费者模式是一种常见的并发模式，它将任务的生产和消费分离，提高了系统的并发性能和可扩展性。生产者负责生成数据并将其发送到通道中，消费者从通道中接收数据并进行处理。 #### 示例代码 ```go package main import ( "fmt" "sync" ) // 生产者函数 func producer(ch chan int, wg *sync.WaitGroup) { defer wg.Done() for i := 0; i < 5; i++ { ch <- i fmt.Printf("生产者发送数据: %d\n", i) } close(ch) } // 消费者函数 func consumer(ch chan int, wg *sync.WaitGroup) { defer wg.Done() for num := range ch { fmt.Printf("消费者接收数据: %d\n", num) } } func main() { var wg sync.WaitGroup ch := make(chan int) // 启动生产者 Goroutine wg.Add(1) go producer(ch, &wg) // 启动消费者 Goroutine wg.Add(1) go consumer(ch, &wg) // 等待所有 Goroutine 完成 wg.Wait() } ``` #### 代码解释 - `producer` 函数作为生产者，向通道 `ch` 中发送 0 到 4 的整数，发送完成后关闭通道。 - `consumer` 函数作为消费者，使用 `for...range` 循环从通道中接收数据并进行处理。 - 在 `main` 函数中，使用 `sync.WaitGroup` 等待生产者和消费者 Goroutine 完成。 ### 扇出（Fan - Out）模式扇出模式是指一个生产者将数据发送到多个通道，多个消费者从这些通道中接收数据并处理，从而实现并行处理。 #### 示例代码 ```go package main import ( "fmt" "sync" ) // 生产者函数 func producer(ch chan int) { for i := 0; i < 5; i++ { ch <- i fmt.Printf("生产者发送数据: %d\n", i) } close(ch) } // 消费者函数 func consumer(id int, ch chan int, wg *sync.WaitGroup) { defer wg.Done() for num := range ch { fmt.Printf("消费者 %d 接收数据: %d\n", id, num) } } func main() { var wg sync.WaitGroup ch := make(chan int) // 启动生产者 Goroutine go producer(ch) // 启动多个消费者 Goroutine numConsumers := 3 for i := 0; i < numConsumers; i++ { wg.Add(1) go consumer(i, ch, &wg) } // 等待所有消费者 Goroutine 完成 wg.Wait() } ``` #### 代码解释 - `producer` 函数向通道 `ch` 中发送 0 到 4 的整数，发送完成后关闭通道。 - `consumer` 函数接收通道中的数据并进行处理，多个消费者 Goroutine 从同一个通道中接收数据。 - 在 `main` 函数中，启动一个生产者 Goroutine 和多个消费者 Goroutine，并使用 `sync.WaitGroup` 等待所有消费者 Goroutine 完成。 ### 扇入（Fan - In）模式扇入模式是指多个生产者将数据发送到多个通道，然后将这些通道的数据合并到一个通道中，由一个或多个消费者从这个合并后的通道中接收数据并处理。 #### 示例代码 ```go package main import ( "fmt" "sync" ) // 生产者函数 func producer(id int, ch chan int, wg *sync.WaitGroup) { defer wg.Done() for i := 0; i < 3; i++ { ch <- id*10 + i fmt.Printf("生产者 %d 发送数据: %d\n", id, id*10+i) } close(ch) } // 合并多个通道的数据到一个通道 func merge(cs ...chan int) chan int { var wg sync.WaitGroup out := make(chan int) // 为每个输入通道启动一个 Goroutine 复制数据到输出通道 output := func(c chan int) { defer wg.Done() for n := range c { out <- n } } wg.Add(len(cs)) for _, c := range cs { go output(c) } // 等待所有输入通道的数据复制完成后关闭输出通道 go func() { wg.Wait() close(out) }() return out } // 消费者函数 func consumer(ch chan int, wg *sync.WaitGroup) { defer wg.Done() for num := range ch { fmt.Printf("消费者接收数据: %d\n", num) } } func main() { var wg sync.WaitGroup // 创建多个生产者通道 numProducers := 2 var chans []chan int for i := 0; i < numProducers; i++ { ch := make(chan int) chans = append(chans, ch) wg.Add(1) go producer(i, ch, &wg) } // 合并多个通道的数据 mergedCh := merge(chans...) // 启动消费者 Goroutine wg.Add(1) go consumer(mergedCh, &wg) // 等待所有 Goroutine 完成 wg.Wait() } ``` #### 代码解释 - `producer` 函数向各自的通道中发送数据，发送完成后关闭通道。 - `merge` 函数将多个通道的数据合并到一个通道中，使用 `sync.WaitGroup` 等待所有输入通道的数据复制完成后关闭输出通道。 - `consumer` 函数从合并后的通道中接收数据并进行处理。 - 在 `main` 函数中，启动多个生产者 Goroutine 和一个消费者 Goroutine，并使用 `sync.WaitGroup` 等待所有 Goroutine 完成。 ### 超时模式超时模式用于在一定时间内等待某个操作完成，如果超过指定时间仍未完成，则进行相应的处理，避免程序无限期阻塞。 #### 示例代码 ```go package main import ( "fmt" "time" ) func doWork(ch chan string) { time.Sleep(2 * time.Second) ch <- "工作完成" } func main() { ch := make(chan string) // 启动工作 Goroutine go doWork(ch) // 设置超时时间 timeout := time.After(1 * time.Second) select { case result := <-ch: fmt.Println(result) case <-timeout: fmt.Println("操作超时") } } ``` #### 代码解释 - `doWork` 函数模拟一个耗时 2 秒的工作，完成后向通道 `ch` 中发送消息。 - 在 `main` 函数中，使用 `time.After` 创建一个超时定时器，使用 `select` 语句监听通道 `ch` 和超时定时器。如果在 1 秒内收到通道 `ch` 的消息，则输出结果；否则，输出“操作超时”。这些并发模式在实际开发中非常有用，可以根据具体的需求选择合适的模式来提高程序的并发性能和可维护性。