有7种重要的channel模式需要理解，因为channel实现了Goroutine之间的通信。
等待结果模式
这是channel的基本使用模式，创建一个goroutine来执行一些任务，然后将执行结果通过channel通知到对应的其他Goroutine。
func WaitForResult() {
ch := make(chan string)
go func() {
time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
ch <- "data"
fmt.Println("child : sent signal")
}()
d := <-ch
fmt.Println("parent : recv'd signal :", d)
time.Sleep(time.Second)
fmt.Println("-------------------------------------------------")
}这里使用不带缓存的channel来接收数据，可以保证子goroutine发送的数据立刻被接收到。
扇出/扇入模式
这种模式是包含多个Goroutine向channel发送数据，要保证数据都能接收到。
func FanOut() {
children := 2000
ch := make(chan string, children)
for c := 0; c < children; c++ {
go func(child int) {
time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
ch <- "data"
fmt.Println("child : sent signal :", child)
}(c)
}
for children > 0 {
d := <-ch
children--
fmt.Println(d)
fmt.Println("parent : recv'd signal :", children)
}
time.Sleep(time.Second)
fmt.Println("-------------------------------------------------")
}这里我们创建了2000个goroutine来执行任务，为了保证Goroutine不会相互影响，采用带缓存的channel来接收执行结果。主goroutine使用for循环来接收channel里面的数据。sleep模拟执行的任务。
等待任务模式
这种模式是子goroutine通过channel接收来自主goroutine发送的数据，也可以是执行任务的函数。
func WaitForTask() {
ch := make(chan string)
go func() {
d := <-ch
fmt.Println("child : recv'd signal :", d)
}()
time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
ch <- "data"
fmt.Println("parent : sent signal")
time.Sleep(time.Second)
fmt.Println("-------------------------------------------------")
}
```这里也是使用不带缓存的channel，子goroutine等待channel发送数据，接收并执行任务。
Goroutine池
该模式还使用了等待任务模式，允许根据资源情况限制子goroutine的个数。
func pooling() {
ch := make(chan string)
g := runtime.GOMAXPROCS(0)
for c := 0; c < g; c++ {
go func(child int) {
for d := range ch {
fmt.Printf("child %d : recv'd signal : %s\n", child, d)
}
fmt.Printf("child %d : recv'd shutdown signal\n", child)
}(c)
}
const work = 100
for w := 0; w < work; w++ {
ch <- "data"
fmt.Println("parent : sent signal :", w)
}
close(ch)
fmt.Println("parent : sent shutdown signal")
time.Sleep(time.Second)
fmt.Println("-------------------------------------------------")
}这里我们创建了一组Goroutine来接收同一个channel发送来的数据。这里高效的原因是多个goroutine可以并行执行，注意不是并发。
首先创建一个不带缓冲的通道。使用无缓冲的通道是至关重要的，因为如果没有信号级别的保证，就不能在发送时执行超时和取消。代码的下一部分决定池将包含的子Goroutines的数量。
g := runtime.GOMAXPROCS(0)该函数可以读取机器cpu核数，也就是能并行执行代码的cpu核数。如果参数大于0，直接返回的是并发个数。
使用for-range读取channel中的数据可以节省代码，当然也可以使用以下代码来读取channel数据：
for c := 0; c < g; c++ {
go func( child int) {
for {
d, wd := <-ch <-- CHANGED
if !wd { <-- CHANGED
break. <-- CHANGED
}
fmt.Printf("child %d : recv'd signal : %s\n", child, d)
}
fmt.Printf("child %d : recv'd shutdown signal\n", child)
}(c)
}Drop模式
该模式在写入channel的数据量比较大的时候，超出缓冲的容量就选择丢弃数据。例如当应用程序负载太大就可以丢弃一些请求。
func Drop() {
const cap = 100
ch := make(chan string, cap)
go func() {
for p := range ch {
fmt.Println("child : recv'd signal :", p)
}
}()
const work = 2000
for w := 0; w < work; w++ {
select {
case ch <- "data":
fmt.Println("parent : sent signal :", w)
default:
fmt.Println("parent : dropped data :", w)
}
}
close(ch)
fmt.Println("parent : sent shutdown signal")
time.Sleep(time.Second)
fmt.Println("-------------------------------------------------")
}我们创建一个带缓存的channel和一个Goroutine来接收任务。在缓冲区被填满之前，Goroutine无法及时处理所有的工作。表示服务已满负荷运行。
在for循环里面使用select，是一个受阻塞的模块，每个case代表一个channel操作，发送或接收。但是，这个select也使用了default关键字，它将select转换为非阻塞调用。关键就在这里，如果channel缓冲区满了，select就会执行default。在web服务里面，我们可以在default中返回500内部错误，或者将请求存起来。
取消模式
取消模式用于在执行一些IO操作的时候，可以选择超时时间。你可以选择取消操作，或者直接退出。
func Cancellation() {
duration := 150 * time.Millisecond
ctx, cancel := context.WithTimeout(context.Background(), duration)
defer cancel()
ch := make(chan string, 1)
go func() {
time.Sleep(time.Duration(rand.Intn(200)) * time.Millisecond)
ch <- "data"
}()
select {
case d := <-ch:
fmt.Println("work complete", d)
case <-ctx.Done():
fmt.Println("work cancelled")
}
time.Sleep(time.Second)
fmt.Println("-------------------------------------------------")
}这里使用context创建超时上下文实例ctx，主Goroutine在select中通过ctx.Done读取是否超时。这里使用defer调用cancel()防止内存溢出。
在主goroutine中select等待ch通道数据或者超时，哪个先完成就执行哪个case。
带信号量的扇入/扇出
这种模式可以随时控制可执行的Goroutine数量。
func FanOutSem() {
children := 2000
ch := make(chan string, children)
g := runtime.GOMAXPROCS(0)
sem := make(chan bool, g)
for c := 0; c < children; c++ {
go func(child int) {
sem <- true
{
t := time.Duration(rand.Intn(200)) * time.Millisecond
time.Sleep(t)
ch <- "data"
fmt.Println("child : sent signal :", child)
}
<-sem
}(c)
}
for children > 0 {
d := <-ch
children--
fmt.Println(d)
fmt.Println("parent : recv'd signal :", children)
}
time.Sleep(time.Second)
fmt.Println("-------------------------------------------------")
}这里一开始创建了一个缓冲为2000的channel。和前面的扇入/扇出没啥区别。另一个chennel sem也被创建了，在每个子goroutine内部使用，可以控制子Goroutine是否能够写入数据容量，缓冲区满的话子goroutine就会阻塞。后面的for循环还是用于等待每个goroutine执行完成。
重试超时模式
这种模式在网络服务中很实用，例如在连接数据库的时候，发起ping操作可能会失败，但是并不希望马上退出，而是在一定时间内发起重试。
func RetryTimeout(ctx context.Context, retryInterval time.Duration,
check func(ctx context.Context) error) {
for {
fmt.Println("perform user check call")
if err := check(ctx); err == nil {
fmt.Println("work finished successfully")
return
}
fmt.Println("check if timeout has expired")
if ctx.Err() != nil {
fmt.Println("time expired 1 :", ctx.Err())
return
}
fmt.Printf("wait %s before trying again\n", retryInterval)
t := time.NewTimer(retryInterval)
select {
case <-ctx.Done():
fmt.Println("timed expired 2 :", ctx.Err())
t.Stop()
return
case <-t.C:
fmt.Println("retry again")
}
}
}这里函数接收一个context指定超时时间，每次重试时间间隔，以及重试函数check，由函数调用者定义。
该函数的核心是for无限循环，在循环内先检查check函数是否执行完成，接着在select中判断是否超时，以及定义重试计时器。
channel取消模式
可以创建一个单独的channel用来实现取消的功能。
func channelCancellation(stop <-chan struct{}) {
ctx, cancel := context.WithCancel(context.Background())
defer cancel()
go func() {
select {
case <-stop:
cancel()
case <-ctx.Done():
}
}()
func(ctx context.Context) error {
req, err := http.NewRequestWithContext(
ctx,
http.MethodGet,
"https://www.ardanlabs.com/blog/index.xml",
nil,
)
if err != nil {
return err
}
_, err = http.DefaultClient.Do(req)
if err != nil {
return err
}
return nil
}(ctx)
}该函数的关键在于创建一个新的goroutine并使用select来等待两个channel发送的数据。第一个channel是一个空结构体类型，另一个是context。在接收到stop通道值时，就调用cancel函数，取消所有接收了对应context函数的执行。