select{} 语句在 Go 语言中用于处理 channel 的操作，当没有任何 case 可执行时，它会无限期阻塞。然而，在并发程序中，不当的使用可能导致意想不到的死锁。本文将深入探讨 select{} 的阻塞行为，解释其为何有时无法如预期般工作，并提供避免死锁以及实现高效并发控制的实用技巧。
select{} 的阻塞机制与死锁
select{} 语句在没有任何 case 准备就绪时会无限期阻塞。这种特性在某些场景下非常有用，例如，等待程序退出信号。然而，如果所有 goroutine 都处于阻塞状态，并且没有其他 goroutine 可以唤醒它们，就会发生死锁。
在提供的代码示例中，死锁的根本原因是 main 函数中的 select{} 语句在所有任务启动后立即执行。虽然 runTask goroutine 会从 activeWorkers channel 中接收值，但 main 函数并没有等待所有任务完成，而是直接进入了 select{} 阻塞状态。此时，所有 goroutine 都被阻塞，导致死锁。
避免死锁的策略
避免死锁的关键在于确保程序在所有任务完成后才进入阻塞状态。以下是一些常用的策略：
-
使用 sync.WaitGroup： sync.WaitGroup 提供了一种等待一组 goroutine 完成的机制。在启动每个 goroutine 之前调用 Add(1)，在 goroutine 完成后调用 Done()，最后调用 Wait() 等待所有 goroutine 完成。
package main import ( "fmt" "math/rand" "sync" "time" ) func runTask(t string, wg *sync.WaitGroup) { defer wg.Done() start := time.Now() fmt.Println("starting task", t) time.Sleep(time.Millisecond * time.Duration(rand.Int31n(1500))) // fake processing time fmt.Println("done running task", t, "in", time.Since(start)) } func main() { files := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"} var wg sync.WaitGroup wg.Add(len(files)) for _, f := range files { go runTask(f, &wg) } wg.Wait() // Wait for all goroutines to complete fmt.Println("All tasks completed.") }在这个例子中，wg.Wait() 会阻塞，直到所有 wg.Done() 被调用，这意味着所有任务都已完成。
-
使用 channel 等待结果： 可以创建一个 channel 用于接收每个任务的完成信号。main 函数可以从这个 channel 中接收足够数量的信号，以确保所有任务都已完成。
package main import ( "fmt" "math/rand" "time" ) func runTask(t string, done chan bool) { defer func() { done <- true }() start := time.Now() fmt.Println("starting task", t) time.Sleep(time.Millisecond * time.Duration(rand.Int31n(1500))) // fake processing time fmt.Println("done running task", t, "in", time.Since(start)) } func main() { files := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"} done := make(chan bool, len(files)) for _, f := range files { go runTask(f, done) } for range files { <-done // Wait for each task to complete } fmt.Println("All tasks completed.") }在这个例子中，done channel 用于接收每个任务的完成信号，main 函数在接收到所有信号后才退出。
使用 Worker Goroutine 池
除了限制 channel 的容量，还可以创建固定数量的 worker goroutine 来处理任务。这种方法更自然，也更易于理解。
package main
import (
"fmt"
"math/rand"
"time"
)
func runTask(t string) string {
start := time.Now()
fmt.Println("starting task", t)
time.Sleep(time.Millisecond * time.Duration(rand.Int31n(1500))) // fake processing time
fmt.Println("done running task", t, "in", time.Since(start))
return t
}
func worker(in chan string, out chan string) {
for t := range in {
out <- runTask(t)
}
}
func main() {
numWorkers := 3
// spawn workers
in, out := make(chan string), make(chan string)
for i := 0; i < numWorkers; i++ {
go worker(in, out)
}
files := []string{"a", "b", "c", "d", "e", "f", "g", "h", "i", "j"}
// schedule tasks
go func() {
for _, f := range files {
in <- f
}
close(in) // Important: close the input channel to signal no more tasks
}()
// get results
for range files {
<-out
}
close(out) // close the output channel after all results are received
fmt.Println("All tasks completed.")
}在这个例子中，创建了固定数量的 worker goroutine，它们从 in channel 中接收任务，并将结果发送到 out channel。重要的是，在所有任务都发送到 in channel 后，需要关闭 in channel，以便 worker goroutine 知道没有更多的任务需要处理。 同样在 main 函数接收完所有结果后，关闭 out channel。
总结
理解 select{} 的阻塞行为对于编写健壮的并发程序至关重要。通过使用 sync.WaitGroup 或 channel 等待任务完成，可以有效地避免死锁。此外，使用 worker goroutine 池可以提供更自然、更高效的并发控制方式。选择哪种方法取决于具体的应用场景和需求。在设计并发程序时，务必仔细考虑 goroutine 的生命周期和它们之间的同步关系，以确保程序的正确性和性能。
