5.4.1. Select语句
Go语言的select语句语法如下：
1 2 3 4 5 6 | select { case sendOrReceive1: block1 ... case sendOrReceiveN: blockN default: blockD } |
在select语句中Go语言会按顺序评估每一个发送和接收语句，如果任何语句可以继续进行（即没有被阻塞），则任意选择这些语句中一个来执行；如果没有可以继续执行的语句（即全部被阻塞），这可以分两种情况讨论，如果存在default语句块，则执行该default块中的语句且会从紧接着select语句的后面恢复执行，如果不存在default语句块，select语句将会阻塞直到至少有一个通信可以继续执行。
select语句的逻辑结果如下。在没有default语句块的情况下，select会被阻塞，且会在一个通信（接收或发送数据）发生时才会执行。如果存在default语句块，则select不会被阻塞且立即实行，这是因为可能有的case语句块有通信发生，或直接执行default语句块。
为了掌握这些语法，让我们来展示两个简短的例子。第一个例子是我们故意设计如此，但是却很好的说明了select语句的工作原理。第二个例子则更贴合实际使用。
1 2 3 4 5 6 7 8 | channels := make([]chan bool, 6) for i := range channels { channels[i] = make(chan bool) } go func() { for { channels[rand.Intn(6)] <- true } |
在上面的代码片段中，我们创建了六个可以发送和接收布尔值的channel。然后，我们创建了一个具有无限循环的goroutine，在这个循环中，每次迭代都可以随机选择一个channel并发送一个true值。当然，该goroutine会立即阻塞，因为这些channel是没有缓冲的且我们还没有从它们中接收数据。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | for i := 0; i < 36; i++ { var x int select { case <-channels[0]: x = 1 case <-channels[1]: x = 2 case <-channels[2]: x = 3 case <-channels[3]: x = 4 case <-channels[4]: x = 5 case <-channels[5]: x = 6 } fmt.Printf("%d ", x) } fmt.Println() 6 4 6 5 4 1 2 1 2 1 5 5 4 6 2 3 6 5 1 5 4 4 3 2 3 3 3 5 3 6 5 2 2 3 6 2 |
上面的代码片段，我们使用了六个channel来模拟一个骰子（严格地说，这是伪随机的）。 select语句会等待其中一个channel发送数据，这种情况下select语句是被阻塞的，因为没有default语句块，但只要有一个或多个channel准备好发送数据，其中一个case语句块就会被随机选择并执行。因为select语句在一个普通的循环中，其执行次数是有限制的。
现在让我们来看一个更贴合实际的例子。假设我们想要在两个单独的数据集上执行大量的计算任务，该计算会产生一系列结果。下面是执行此类计算的函数。
1 2 3 4 5 6 7 8 9 | func expensiveComputation(data Data, answer chan int, done chan bool) { // setup ... finished := false for !finished { // computation ... answer <- result } done <- true } |
该函数接收要处理的数据和两个channel作为参数。answer channel用于将每个结果发送到监视代码，done channel用于通知监视代码计算已完成。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | // setup ... const allDone = 2 doneCount := 0 answerα := make(chan int) answerβ := make(chan int) defer func() { close(answerα) close(answerβ) }() done := make(chan bool) defer func() { close(done) }() go expensiveComputation(data1, answerα, done) go expensiveComputation(data2, answerβ, done) for doneCount != allDone { var which, result int select { case result = <-answerα: which = 'α' case result = <-answerβ: which = 'β' case <-done: doneCount++ } if which != 0 { fmt.Printf("%c→%d ", which, result) } } fmt.Println() α→3 β→3 α→0 β→9 α→0 β→2 α→9 β→3 α→6 β→1 α→0 β→8 α→8 β→5 α→0 β→0 α→3 |
上面的代码创建了channel，开始耗时的计算，监视进度，并进行最后的清理工作，它们之间完全互不影响。
我们首先创建了answerα 和answerβ这两个channel来接收结果，其中一个channel用于跟踪计算何时完成。我们创建了defer关键字修饰的匿名函数，并在其中将channel关闭，这样一旦这两个channel不再需要时就可以将它们关闭，即外层函数返回时。接下来，我们提供数据并开始耗时的计算任务（在它们自己的goroutine中），每个goroutine都有自己的answer channel和共享的done channel用于通信。
我们本可以使用同一个answer channel，但如果我们这样做，我们就很难知道哪个结果由哪个数据给出（当然，这可能并不重要）。如果我们想要使用同一个channel，并想知道哪个数据会产生哪种结果，我们可以创建一个含有结果字段的struct结构体，例如：type Answer struct{id,answer int}.
随着耗时的计算任务开始于它们各自的goroutine（但被阻塞，因为是非缓冲channel），我们也已经准备好接收结果。for循环的每次迭代，which和result的值都会被重置，select语句会阻塞直至从可以执行的case子句中随机选择一个。如果其中一个answer已就绪，我们就重置which的值并将结果打印出来。如果done channel就绪，我们就将doneCount计数器的值加一，当doneCount的值等于我们要处理的数据数量时，计算任务完成，for循环结束。
一旦跳出for循环，我们就会知道这两个计算任务的goroutine将不再发送数据到它们的channel（因为它们在完成后从自身的无限for循环中跳了出来）。当函数返回时，defer代码块会将channel关闭并释放它们使用的资源。在这之后，垃圾收集器会清理goroutine本身，因为它们已不再执行且channel已被关闭。
Go语言的通信和并发是非常灵活且功能强大的，第7章将专门讨论这些问题。
