6.3 通道
并发编程的挑战主要在于数据分享。如果你的go协程没有共享数据，你就不需要担心同步他们。但是，对于所有的系统，这不是一个选择。实际上，考虑到很多系统以完全相反的目标构建：通过多个请求来分享数据。一个内存中的缓存或者一个数据库都是这方面的好例子。这正变得越来越流行的事实。
通道通过使共享数据不相干让并发编程变得更加理智。一个通道是一个通信管道，它用于go协程之间传递数据。换句话说，一个go协程可以通过通道传递数据给另外一个go协程。其结果就是，在任何时候，仅有一个go协程可以访问数据。
通道所有其他的东西一样，也有类型。这种类型类型的数据就是将要在我们通道中传递的数据。例如，创建一个通道，这个通道可以用来传递一个整数，我们可以这样：
c := make(chan int)
这个通道的类型是chan int。因此，将这个通道传递给一个函数是，可以这样声明：
func worker(c chan int) { ... }
通道支持2中操作：接收和发送。我们可以使用下面方式往通道发送数据：
CHANNEL <- DATA
可以使用下面方式从通道接收数据：
VAR := <-CHANNEL
箭头的方向就是数据的流动方向。当发送数据时，数据流入通道。当发送数据时，数据是流出通道。
最后，在查看我们的第一个例子之前，我们需要知道从一个通道接收或者发送数据时会阻塞。当我们从一个通道接收数据时，直到数据可用go协程才会继续执行。类似的，往一个通道发送数据时，在数据被接收之前go协程也不会继续执行。
考虑到洗个系统的输入数据，我们想通过不同的协程去处理这些数据。这是一种常见的需求。如果通过go协程接收输入的数据并进行数据密集型处理。那么在客户端会有超时风险，首先，我们将写出我们的worker。这可以是一个简单的函数，但是我会让它变成一个结构体的部分，因为我们之前从来没有这样使用过go协程：
type Worker struct {
id int
}
func (w Worker) process(c chan int) {
for {
data := <-c
fmt.Printf("worker %d got %d\n", w.id, data)
}
}
我们的worker很简单。它会一直等待数据，直到数据可用然后处理它。它在一个循环中，永远尽职的等待更多的数据并处理。
为了使用上面的worker，我们首先要做的是启动一些worker：
c := make(chan int)
for i := 0; i < 4; i++ {
worker := Worker{id: i}
go worker.process(c)
}
然后我们可以给它们一些工作：
for {
c <- rand.Int()
time.Sleep(time.Millisecond * 50)
}
这是完整的代码，运行它：
package main
import (
"fmt"
"math/rand"
"time"
)
func main() {
c := make(chan int)
for i := 0; i < 5; i++ {
worker := &Worker{id: i}
go worker.process(c)
}
for {
c <- rand.Int()
time.Sleep(time.Millisecond * 50)
}
}
type Worker struct {
id int
}
func (w *Worker) process(c chan int) {
for {
data := <-c
fmt.Printf("worker %d got %d\n", w.id, data)
}
}
我们不知道哪个worker将获得数据。我们所知道的是，go语言确保了往一个通道发送数据时，仅有一个单独的接收器可以接受。
需要指出的是通道是共享状态的唯一方式，通过通道我们可以并发安全的发送和接收数据。通道提供了我们需要的所有同步代码，并且也确保在任意的特定时刻只有一个go协程可以访问一个特定的数据。
6.3.1 带缓存的通道
在上面的代码中，如果输入的数据超过我们可以处理的数据会发生什么？你可以模拟这种场景，在worker接收到数据后，让worker执行time.Sleep：
for {
data := <-c
fmt.Printf("worker %d got %d\n", w.id, data)
time.Sleep(time.Millisecond * 500)
}
在main函数中会发什么呢？接收用户的输入数据（这里通过一个随机的数字生成器模拟）会被阻塞，因为往通道发送数据时没有可用的接收者。
在这种情况下，你需要确保数据被处理，你可能想要让客户端阻塞。在其他情况下，你可能愿意不确保数据被处理。这里有一些流行的策略能完成此事。首先是将数据缓存起来。如果没有worker可用，我们想将数据暂时存放在一个有序的队列中。通道拥有这种内置额度缓存能力。当我们使用make创建一个通道时，我们可以指定通道的长度：
c := make(chan int, 100)
你可以改变，但是你将注意到处理过程仍然震荡。当缓存的通道不能添加更多的容量；它只不过是为挂起的作业提供一个队列，以一种更好的方式处理数据突然飙升。在我们示例中，我们可以连续不断的发送更多的数据，并且worker也能处理这些数据。
虽然如此，事实上，我们可以查看通道的长度了解到带缓存的通道的缓冲作用：
for {
c <- rand.Int()
fmt.Println(len(c))
time.Sleep(time.Millisecond * 50)
}
你可以看到带缓存的通道长度在不断增大，直到装满为止，此时，往通道发送的数据又开始被阻塞。
6.3.2 select
即使借助缓存，有一点需要指出的是，我们需要开始丢弃一些消息，我们不能使用一个无限大的内存，并指望人工的释放它。所以我们使用go语言的select。
在语法结构上，select看起来有点类似switch。通过select，我们能写出一些针对通道不可写情况下的代码。首先，让我们去掉我们通道的缓存，这样可以更清晰的看到select是如何工作的。
c := make(chan int)
接下来，我们修改for循环：
for {
select {
case c <- rand.Int():
//可选的代码
default:
//这里可以留下空行以丢弃数据
fmt.Println("dropped")
}
time.Sleep(time.Millisecond * 50)
}
我们每秒往通道中发送20个信息，但是我们的程序每秒只能处理10个信息；因此，有一半的信息被丢弃。
这仅仅只是我们使用select完成一些事的开始。使用select的最主要目的是通过它管理多个通道。给定多个通道，select将阻塞直到有一个通道可用。如果没有可用的通道，当提供了default语句时，执行该分支。当多个通道都可用时，选择其中的一个通道是随机的。
很难想出一个简单的例子来证明这种行为，因为这是一种高级特性。在下一小节可能有助于说明这个问题。
6.3.3 超时
我们已经学习了带缓存的信息并且也简单的丢弃它们。另外一种比较流行的做法是使用超时。我们将阻塞一段时间，但是不是一直阻塞。这在go中很容易实现。老实说，这个语法有点难于接受，但是它是比较灵活和有用的特性，我基本不能没有它。
为了是阻塞达到最大值，我们可以使用time.After函数。让我们看看它会发生什么神奇的事。通过使用这种方式，我们发送器变成：
for {
select {
case c <- rand.Int():
case <-time.After(time.Millisecond * 100):
fmt.Println("timed out")
}
time.Sleep(time.Millisecond * 50)
}
time.After将返回一个通道，所以我们可以对它使用select语句。这个通道在经过指定的时间后会被写入。就是这样。没有什么比这个更神奇了。如果你依然觉得奇怪，这里实现了一个after，如下所示：
func after(d time.Duration) chan bool {
c := make(chan bool)
go func() {
time.Sleep(d)
c <- true
}()
return c
}
回到我们的select语句，这里有一些好玩的东西。首先，如果你在后面添加default分之会发生什么？你能猜到吗？试试。如果你不确定会发生什么，记住如果通道不可用的话，default分支会被立即执行。
此外，time.After是一个chan time.Time类型的通道。在上面的例子中，我们将发送给通道的值简单丢弃掉。如果你想，你也可以获取到这个值：
case t := <-time.After(time.Millisecond * 100):
fmt.Println("timed out at", t)
密切注意我们的select。注意我们正在往c中发送数据，但是从time.After收取。不管我们是从通道中接收数据、发送数据或者收发数据，select工作机制都一样：
- 第一个可用的通道被选中
- 如果多个通道可用，随机选中一个通道
- 如果没有通道可用，
default分之被执行 - 如果没有
default分之，select将阻塞
最后，在for循环中使用select也是比较常见的，例如：
for {
select {
case data := <-c:
fmt.Printf("worker %d got %d\n", w.id, data)
case <-time.After(time.Millisecond * 10):
fmt.Println("Break time")
time.Sleep(time.Second)
}
}