有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函数的执行。