出于性能考虑的建议:

    实践经验表明,如果你使用并行运算获得高于串行运算的效率:在协程内部已经完成的大部分工作,其开销比创建协程和协程间通信还高。

    1 出于性能考虑建议使用带缓存的通道:

    使用带缓存的通道可以很轻易成倍提高它的吞吐量,某些场景其性能可以提高至 10 倍甚至更多。通过调整通道的容量,甚至可以尝试着更进一步的优化其性能。

    2 限制一个通道的数据数量并将它们封装成一个数组:

    如果使用通道传递大量单独的数据,那么通道将变成性能瓶颈。然而,将数据块打包封装成数组,在接收端解压数据时,性能可以提高至 10 倍。

    创建:ch := make(chan type,buf)

    (1)如何使用 for 或者 for-range 遍历一个通道:

    1. for v := range ch {
    2. // do something with v
    3. }

    (2)如何检测一个通道 ch 是否关闭:

    1. //read channel until it closes or error-condition
    2. for {
    3. if input, open := <-ch; !open {
    4. break
    5. }
    6. fmt.Printf("%s", input)
    7. }

    或者使用(1)自动检测。

    (3)如何通过一个通道让主程序等待直到协程完成:

    (信号量模式):

    1. ch := make(chan int) // Allocate a channel.
    2. // Start something in a goroutine; when it completes, signal on the channel.
    3. go func() {
    4. // doSomething
    5. ch <- 1 // Send a signal; value does not matter.
    6. }()
    7. doSomethingElseForAWhile()
    8. <-ch // Wait for goroutine to finish; discard sent value.

    如果希望程序一直阻塞,在匿名函数中省略 ch <- 1 即可。

    (4)通道的工厂模板:以下函数是一个通道工厂,启动一个匿名函数作为协程以生产通道:

    1. func pump() chan int {
    2. ch := make(chan int)
    3. go func() {
    4. for i := 0; ; i++ {
    5. ch <- i
    6. }
    7. }()
    8. return ch
    9. }

    (5)通道迭代器模板:

    (6)如何限制并发处理请求的数量:参考 章节 14.11

    (7)如何在多核 CPU 上实现并行计算:参考 章节 14.13

    (8)如何终止一个协程:runtime.Goexit()

    (9)简单的超时模板:

    1. timeout := make(chan bool, 1)
    2. go func() {
    3. time.Sleep(1e9) // one second
    4. timeout <- true
    5. }()
    6. select {
    7. case <-ch:
    8. // a read from ch has occurred
    9. case <-timeout:
    10. // the read from ch has timed out
    11. }

    (10)如何使用输入通道和输出通道代替锁:

    1. func Worker(in, out chan *Task) {
    2. for {
    3. t := <-in
    4. process(t)
    5. out <- t
    6. }
    7. }

    (11)如何在同步调用运行时间过长时将之丢弃:参考 章节 14.5 第二个变体

    (12)如何在通道中使用计时器和定时器:参考 章节 14.5

    (13)典型的服务器后端模型:参考 章节 14.4