Golang channel 使用总结

不同于传统的多线程并发模型使用共享内存来实现线程间通信的方式，golang 的哲学是通过 channel 进行协程 (goroutine) 之间的通信来实现数据共享：

Do not communicate by sharing memory; instead, share memory by communicating.

这种方式的优点是通过提供原子的通信原语，避免了竞态情形 (race condition) 下复杂的锁机制。channel 可以看成一个 FIFO 队列，对 FIFO 队列的读写都是原子的操作，不需要加锁。对 channel 的操作行为结果总结如下：

操作nil channelclosed channelnot-closed non-nil channel
closepanicpanic成功 close
写 ch <-一直阻塞panic阻塞或成功写入数据
读 <- ch一直阻塞读取对应类型零值阻塞或成功读取数据

读取一个已关闭的 channel 时，总是能读取到对应类型的零值，为了和读取非空未关闭 channel 的行为区别，可以使用两个接收值：

 
 
 
 
      
  
  
  
  1. // ok is false when ch is closed  
    2.   
  
  
  
  2. v, ok := <-ch 
    3.

golang 中大部分类型都是值类型（只有 slice / channel / map 是引用类型），读/写类型是值类型的 channel 时，如果元素 size 比较大时，应该使用指针代替，避免频繁的内存拷贝开销。

内部实现

如图所示，在 channel 的内部实现中（具体定义在 $GOROOT/src/runtime/chan.go 里），维护了 3 个队列：

  • 读等待协程队列 recvq，维护了阻塞在读此 channel 的协程列表
  •  写等待协程队列 sendq，维护了阻塞在写此 channel 的协程列表
  •  缓冲数据队列 buf，用环形队列实现，不带缓冲的 channel 此队列 size 则为 0

img

当协程尝试从未关闭的 channel 中读取数据时，内部的操作如下：

    1.  当 buf 非空时，此时 recvq 必为空，buf 弹出一个元素给读协程，读协程获得数据后继续执行，此时若 sendq 非空，则从 sendq 中弹出一个写协程转入 running 状态，待写数据入队列 buf ，此时读取操作 <- ch 未阻塞；

    2.  当 buf 为空但 sendq 非空时（不带缓冲的 channel)，则从 sendq 中弹出一个写协程转入 running 状态，待写数据直接传递给读协程，读协程继续执行，此时读取操作 <- ch 未阻塞；

    3.  当 buf 为空并且 sendq 也为空时，读协程入队列 recvq 并转入 blocking 状态，当后续有其他协程往 channel 写数据时，读协程才会重新转入 running 状态，此时读取操作 <- ch 阻塞。

类似的，当协程尝试往未关闭的 channel 中写入数据时，内部的操作如下：

  1.  当队列 recvq 非空时，此时队列 buf 必为空，从 recvq 弹出一个读协程接收待写数据，此读协程此时结束阻塞并转入 running 状态，写协程继续执行，此时写入操作 ch <- 未阻塞；
  2.  当队列 recvq 为空但 buf 未满时，此时 sendq 必为空，写协程的待写数据入 buf 然后继续执行，此时写入操作 ch <- 未阻塞；
  3.  当队列 recvq 为空并且 buf 为满时，此时写协程入队列 sendq 并转入 blokcing 状态，当后续有其他协程从 channel 中读数据时，写协程才会重新转入 running 状态，此时写入操作 ch <- 阻塞。

当关闭 non-nil channel 时，内部的操作如下：

  1.   当队列 recvq 非空时，此时 buf 必为空，recvq 中的所有协程都将收到对应类型的零值然后结束阻塞状态；
  2.   当队列 sendq 非空时，此时 buf 必为满，sendq 中的所有协程都会产生 panic ，在 buf 中数据仍然会保留直到被其他协程读取。

使用场景

除了常规的用来在协程之间传递数据外，本节列出了一些特殊的使用 channel 的场景。

futures / promises

golang 虽然没有直接提供 futrue / promise 模型的操作原语，但通过 goroutine 和 channel 可以实现类似的功能：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import (  
    3.   
  
  
  
  3.     "io/ioutil"  
    4.   
  
  
  
  4.     "log"  
    5.   
  
  
  
  5.     "net/http"  
    6.   
  
  
  
  6. )  
    7.   
  
  
  
  7. // RequestFuture, http request promise. 
    8.   
  
  
  
  8. func RequestFuture(url string) <-chan []byte {  
    9.   
  
  
  
  9.     c := make(chan []byte, 1) 
    10.   
  
  
  
  10.     go func() {  
    11.   
  
  
  
  11.         var body []byte  
    12.   
  
  
  
  12.         defer func() {  
    13.   
  
  
  
  13.             c <- body  
    14.   
  
  
  
  14.         }()  
    15.   
  
  
  
  15.         res, err := http.Get(url)  
    16.   
  
  
  
  16.         if err != nil { 
    17.   
  
  
  
  17.              return  
    18.   
  
  
  
  18.         }  
    19.   
  
  
  
  19.         defer res.Body.Close()  
    20.   
  
  
  
  20.         body, _ = ioutil.ReadAll(res.Body)  
    21.   
  
  
  
  21.     }() 
    22.   
  
  
  
  22.     return c  
    23.   
  
  
  
  23. }  
    24.   
  
  
  
  24. func main() {  
    25.   
  
  
  
  25.     future := RequestFuture("https://api.github.com/users/octocat/orgs")  
    26.   
  
  
  
  26.     body := <-future  
    27.   
  
  
  
  27.     log.Printf("reponse length: %d", len(body))  
    28.   
  
  
  
  28. } 
    29.

条件变量 (condition variable)

类型于 POSIX 接口中线程通知其他线程某个事件发生的条件变量，channel 的特性也可以用来当成协程之间同步的条件变量。因为 channel 只是用来通知，所以 channel 中具体的数据类型和值并不重要，这种场景一般用 strct {} 作为 channel 的类型。

一对一通知

类似 pthread_cond_signal() 的功能，用来在一个协程中通知另个某一个协程事件发生：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import (  
    3.   
  
  
  
  3.     "fmt"  
    4.   
  
  
  
  4.     "time"  
    5.   
  
  
  
  5. )  
    6.   
  
  
  
  6. func main() {  
    7.   
  
  
  
  7.     ch := make(chan struct{})  
    8.   
  
  
  
  8.     nums := make([]int, 100)  
    9.   
  
  
  
  9.     go func() {  
    10.   
  
  
  
  10.         time.Sleep(time.Second)  
    11.   
  
  
  
  11.         for i := 0; i < len(nums); i++ {  
    12.   
  
  
  
  12.             nums[i] = i  
    13.   
  
  
  
  13.         }  
    14.   
  
  
  
  14.         // send a finish signal  
    15.   
  
  
  
  15.         ch <- struct{}{}  
    16.   
  
  
  
  16.     }()  
    17.   
  
  
  
  17.     // wait for finish signal  
    18.   
  
  
  
  18.     <-ch  
    19.   
  
  
  
  19.     fmt.Println(nums)  
    20.   
  
  
  
  20. } 
    21.

广播通知

类似 pthread_cond_broadcast() 的功能。利用从已关闭的 channel 读取数据时总是非阻塞的特性，可以实现在一个协程中向其他多个协程广播某个事件发生的通知：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import (  
    3.   
  
  
  
  3.     "fmt"  
    4.   
  
  
  
  4.     "time"  
    5.   
  
  
  
  5. )  
    6.   
  
  
  
  6. func main() {  
    7.   
  
  
  
  7.     N := 10  
    8.   
  
  
  
  8.     exit := make(chan struct{})  
    9.   
  
  
  
  9.     done := make(chan struct{}, N)  
    10.   
  
  
  
  10.     // start N worker goroutines  
    11.   
  
  
  
  11.     for i := 0; i < N; i++ {  
    12.   
  
  
  
  12.         go func(n int) {  
    13.   
  
  
  
  13.             for {  
    14.   
  
  
  
  14.                 select {  
    15.   
  
  
  
  15.                 // wait for exit signal  
    16.   
  
  
  
  16.                 case <-exit:  
    17.   
  
  
  
  17.                     fmt.Printf("worker goroutine #%d exit\n", n)  
    18.   
  
  
  
  18.                     done <- struct{}{}  
    19.   
  
  
  
  19.                     return  
    20.   
  
  
  
  20.                 case <-time.After(time.Second):  
    21.   
  
  
  
  21.                     fmt.Printf("worker goroutine #%d is working...\n", n)  
    22.   
  
  
  
  22.                 }  
    23.   
  
  
  
  23.             }  
    24.   
  
  
  
  24.         }(i)  
    25.   
  
  
  
  25.     }  
    26.   
  
  
  
  26.     time.Sleep(3 * time.Second)  
    27.   
  
  
  
  27.     // broadcast exit signal  
    28.   
  
  
  
  28.     close(exit)  
    29.   
  
  
  
  29.     // wait for all worker goroutines exit  
    30.   
  
  
  
  30.     for i := 0; i < N; i++ {  
    31.   
  
  
  
  31.         <-done  
    32.   
  
  
  
  32.     }  
    33.   
  
  
  
  33.     fmt.Println("main goroutine exit")  
    34.   
  
  
  
  34. } 
    35.

信号量

channel 的读/写相当于信号量的 P / V 操作，下面的示例程序中 channel 相当于信号量：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import (  
    3.   
  
  
  
  3.     "log"  
    4.   
  
  
  
  4.     "math/rand"  
    5.   
  
  
  
  5.     "time"  
    6.   
  
  
  
  6. )  
    7.   
  
  
  
  7. type Seat int  
    8.   
  
  
  
  8. type Bar chan Seat  
    9.   
  
  
  
  9. func (bar Bar) ServeConsumer(customerId int) {  
    10.   
  
  
  
  10.     log.Print("-> consumer#", customerId, " enters the bar")  
    11.   
  
  
  
  11.     seat := <-bar // need a seat to drink  
    12.   
  
  
  
  12.     log.Print("consumer#", customerId, " drinks at seat#", seat)  
    13.   
  
  
  
  13.     time.Sleep(time.Second * time.Duration(2+rand.Intn(6)))  
    14.   
  
  
  
  14.     log.Print("<- consumer#", customerId, " frees seat#", seat)  
    15.   
  
  
  
  15.     bar <- seat // free the seat and leave the bar  
    16.   
  
  
  
  16. }  
    17.   
  
  
  
  17. func main() {  
    18.   
  
  
  
  18.     rand.Seed(time.Now().UnixNano())  
    19.   
  
  
  
  19.     bar24x7 := make(Bar, 10) // the bar has 10 seats  
    20.   
  
  
  
  20.     // Place seats in an bar.  
    21.   
  
  
  
  21.     for seatId := 0; seatId < cap(bar24x7); seatId++ {  
    22.   
  
  
  
  22.         bar24x7 <- Seat(seatId) // none of the sends will block  
    23.   
  
  
  
  23.     }  
    24.   
  
  
  
  24.     // a new consumer try to enter the bar for each second  
    25.   
  
  
  
  25.     for customerId := 0; ; customerId++ {  
    26.   
  
  
  
  26.         time.Sleep(time.Second)  
    27.   
  
  
  
  27.         go bar24x7.ServeConsumer(customerId)  
    28.   
  
  
  
  28.     }  
    29.   
  
  
  
  29. } 
    30.

互斥量

互斥量相当于二元信号里，所以 cap 为 1 的 channel 可以当成互斥量使用：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import "fmt"  
    3.   
  
  
  
  3. func main() {  
    4.   
  
  
  
  4.     mutex := make(chan struct{}, 1) // the capacity must be one  
    5.   
  
  
  
  5.     counter := 0  
    6.   
  
  
  
  6.     increase := func() {  
    7.   
  
  
  
  7.         mutex <- struct{}{} // lock  
    8.   
  
  
  
  8.         counter++  
    9.   
  
  
  
  9.         <-mutex // unlock  
    10.   
  
  
  
  10.     }  
    11.   
  
  
  
  11.     increase1000 := func(done chan<- struct{}) {  
    12.   
  
  
  
  12.         for i := 0; i < 1000; i++ {  
    13.   
  
  
  
  13.             increase()  
    14.   
  
  
  
  14.         }  
    15.   
  
  
  
  15.         done <- struct{}{}  
    16.   
  
  
  
  16.     }  
    17.   
  
  
  
  17.     done := make(chan struct{})  
    18.   
  
  
  
  18.     go increase1000(done)  
    19.   
  
  
  
  19.     <-done; <-done  
    20.   
  
  
  
  20.     fmt.Println(counter) // 2000  
    21.   
  
  
  
  21. } 
    22.

关闭 channel

关闭不再需要使用的 channel 并不是必须的。跟其他资源比如打开的文件、socket 连接不一样，这类资源使用完后不关闭后会造成句柄泄露，channel 使用完后不关闭也没有关系，channel 没有被任何协程用到后最终会被 GC 回收。关闭 channel 一般是用来通知其他协程某个任务已经完成了。golang 也没有直接提供判断 channel 是否已经关闭的接口，虽然可以用其他不太优雅的方式自己实现一个：

 
 
 
 
      
  
  
  
  1. func isClosed(ch chan int) bool {  
    2.   
  
  
  
  2.     select {  
    3.   
  
  
  
  3.     case <-ch:  
    4.   
  
  
  
  4.         return true  
    5.   
  
  
  
  5.     default:  
    6.   
  
  
  
  6.     }  
    7.   
  
  
  
  7.     return false  
    8.   
  
  
  
  8. } 
    9.

不过实现一个这样的接口也没什么必要。因为就算通过 isClosed() 得到当前 channel 当前还未关闭，如果试图往 channel 里写数据，仍然可能会发生 panic ，因为在调用 isClosed() 后，其他协程可能已经把 channel 关闭了。关闭 channel 时应该注意以下准则：

  •  不要在读取端关闭 channel ，因为写入端无法知道 channel 是否已经关闭，往已关闭的 channel 写数据会 panic ；
  •  有多个写入端时，不要再写入端关闭 channle ，因为其他写入端无法知道 channel 是否已经关闭，关闭已经关闭的 channel 会发生 panic ；
  •  如果只有一个写入端，可以在这个写入端放心关闭 channel 。

关闭 channel 粗暴一点的做法是随意关闭，如果产生了 panic 就用 recover 避免进程挂掉。稍好一点的方案是使用标准库的 sync 包来做关闭 channel 时的协程同步，不过使用起来也稍微复杂些。下面介绍一种优雅些的做法。

一写多读

这种场景下这个唯一的写入端可以关闭 channel 用来通知读取端所有数据都已经写入完成了。读取端只需要用 for range 把 channel 中数据遍历完就可以了，当 channel 关闭时，for range 仍然会将 channel 缓冲中的数据全部遍历完然后再退出循环：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import (  
    3.   
  
  
  
  3.     "fmt"  
    4.   
  
  
  
  4.     "sync"  
    5.   
  
  
  
  5. )  
    6.   
  
  
  
  6. func main() {  
    7.   
  
  
  
  7.     wg := &sync.WaitGroup{}  
    8.   
  
  
  
  8.     ch := make(chan int, 100)  
    9.   
  
  
  
  9.     send := func() { 
    10.   
  
  
  
  10.          for i := 0; i < 100; i++ {  
    11.   
  
  
  
  11.             ch <- i  
    12.   
  
  
  
  12.         }  
    13.   
  
  
  
  13.         // signal sending finish  
    14.   
  
  
  
  14.         close(ch) 
    15.   
  
  
  
  15.      }  
    16.   
  
  
  
  16.     recv := func(id int) {  
    17.   
  
  
  
  17.         defer wg.Done()  
    18.   
  
  
  
  18.         for i := range ch {  
    19.   
  
  
  
  19.             fmt.Printf("receiver #%d get %d\n", id, i)  
    20.   
  
  
  
  20.         }  
    21.   
  
  
  
  21.         fmt.Printf("receiver #%d exit\n", id)  
    22.   
  
  
  
  22.     }  
    23.   
  
  
  
  23.     wg.Add(3)  
    24.   
  
  
  
  24.     go recv(0)  
    25.   
  
  
  
  25.     go recv(1)  
    26.   
  
  
  
  26.     go recv(2)  
    27.   
  
  
  
  27.     send()  
    28.   
  
  
  
  28.     wg.Wait()  
    29.   
  
  
  
  29. } 
    30.

多写一读

这种场景下虽然可以用 sync.Once 来解决多个写入端重复关闭 channel 的问题，但更优雅的办法设置一个额外的 channel ，由读取端通过关闭来通知写入端任务完成不要再继续再写入数据了：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import (  
    3.   
  
  
  
  3.     "fmt"  
    4.   
  
  
  
  4.     "sync"  
    5.   
  
  
  
  5. )  
    6.   
  
  
  
  6. func main() {  
    7.   
  
  
  
  7.     wg := &sync.WaitGroup{}  
    8.   
  
  
  
  8.     ch := make(chan int, 100)  
    9.   
  
  
  
  9.     done := make(chan struct{})  
    10.   
  
  
  
  10.     send := func(id int) {  
    11.   
  
  
  
  11.         defer wg.Done()  
    12.   
  
  
  
  12.         for i := 0; ; i++ {  
    13.   
  
  
  
  13.             select {  
    14.   
  
  
  
  14.             case <-done:  
    15.   
  
  
  
  15.                 // get exit signal  
    16.   
  
  
  
  16.                 fmt.Printf("sender #%d exit\n", id)  
    17.   
  
  
  
  17.                 return  
    18.   
  
  
  
  18.             case ch <- id*1000 + i:  
    19.   
  
  
  
  19.             }  
    20.   
  
  
  
  20.         }  
    21.   
  
  
  
  21.     }  
    22.   
  
  
  
  22.     recv := func() {  
    23.   
  
  
  
  23.         count := 0  
    24.   
  
  
  
  24.         for i := range ch {  
    25.   
  
  
  
  25.             fmt.Printf("receiver get %d\n", i)  
    26.   
  
  
  
  26.             count++  
    27.   
  
  
  
  27.             if count >= 1000 {  
    28.   
  
  
  
  28.                 // signal recving finish  
    29.   
  
  
  
  29.                 close(done)  
    30.   
  
  
  
  30.                 return  
    31.   
  
  
  
  31.             }  
    32.   
  
  
  
  32.         }  
    33.   
  
  
  
  33.     }  
    34.   
  
  
  
  34.     wg.Add(3)  
    35.   
  
  
  
  35.     go send(0)  
    36.   
  
  
  
  36.     go send(1)  
    37.   
  
  
  
  37.     go send(2)  
    38.   
  
  
  
  38.     recv()  
    39.   
  
  
  
  39.     wg.Wait() 
    40.   
  
  
  
  40. } 
    41.

多写多读

这种场景稍微复杂，和上面的例子一样，也需要设置一个额外 channel 用来通知多个写入端和读取端。另外需要起一个额外的协程来通过关闭这个 channel 来广播通知：

 
 
 
 
      
  
  
  
  1. package main  
    2.   
  
  
  
  2. import (  
    3.   
  
  
  
  3.     "fmt"  
    4.   
  
  
  
  4.     "sync"  
    5.   
  
  
  
  5.     "time"  
    6.   
  
  
  
  6. ) 
    7.   
  
  
  
  7. func main() {  
    8.   
  
  
  
  8.     wg := &sync.WaitGroup{}  
    9.   
  
  
  
  9.     ch := make(chan int, 100)  
    10.   
  
  
  
  10.     done := make(chan struct{}) 
    11.   
  
  
  
  11.     send := func(id int) {  
    12.   
  
  
  
  12.         defer wg.Done()  
    13.   
  
  
  
  13.         for i := 0; ; i++ {  
    14.   
  
  
  
  14.             select {  
    15.   
  
  
  
  15.             case <-done:  
    16.   
  
  
  
  16.                 // get exit signal  
    17.   
  
  
  
  17.                 fmt.Printf("sender #%d exit\n", id)  
    18.   
  
  
  
  18.                 return  
    19.   
  
  
  
  19.             case ch <- id*1000 + i:  
    20.   
  
  
  
  20.             }  
    21.   
  
  
  
  21.         }  
    22.   
  
  
  
  22.     }  
    23.   
  
  
  
  23.     recv := func(id int) {  
    24.   
  
  
  
  24.         defer wg.Done()  
    25.   
  
  
  
  25.         for {  
    26.   
  
  
  
  26.             select { 
    27.   
  
  
  
  27.              case <-done:  
    28.   
  
  
  
  28.                 // get exit signal  
    29.   
  
  
  
  29.                 fmt.Printf("receiver #%d exit\n", id)  
    30.   
  
  
  
  30.                 return  
    31.   
  
  
  
  31.             case i := <-ch:  
    32.   
  
  
  
  32.                 fmt.Printf("receiver #%d get %d\n", id, i)  
    33.   
  
  
  
  33.                 time.Sleep(time.Millisecond)  
    34.   
  
  
  
  34.             }  
    35.   
  
  
  
  35.         }  
    36.   
  
  
  
  36.     }  
    37.   
  
  
  
  37.     wg.Add(6)  
    38.   
  
  
  
  38.     go send(0)  
    39.   
  
  
  
  39.     go send(1)  
    40.   
  
  
  
  40.     go send(2)  
    41.   
  
  
  
  41.     go recv(0)  
    42.   
  
  
  
  42.     go recv(1)  
    43.   
  
  
  
  43.     go recv(2)   
    44.   
  
  
  
  44.     time.Sleep(time.Second)  
    45.   
  
  
  
  45.     // signal finish  
    46.   
  
  
  
  46.     close(done)  
    47.   
  
  
  
  47.     // wait all sender and receiver exit  
    48.   
  
  
  
  48.     wg.Wait()  
    49.   
  
  
  
  49. } 
    50.

总结

channle 作为 golang 最重要的特性，用起来还是比较爽的。传统的 C 里要实现类型的功能的话，一般需要用到 socket 或者 FIFO 来实现，另外还要考虑数据包的完整性与并发冲突的问题，channel 则屏蔽了这些底层细节，使用者只需要考虑读写就可以了。channel 是引用类型，了解一下 channel 底层的机制对更好的使用 channel 还是很用必要的。虽然操作原语简单，但涉及到阻塞的问题，使用不当可能会造成死锁或者无限制的协程创建最终导致进程挂掉。

channel 除在可以用来在协程之间通信外，其阻塞和唤醒协程的特性也可以用作协程之间的同步机制，文中也用示例简单介绍了这种场景下的用法。

关闭 channel 并不是必须的，只要没有协程没用引用 channel ，最终会被 GC 清理。所以使用的时候要特别注意，不要让协程阻塞在 channel 上，这种情况很难检测到，而且会造成 channel 和阻塞在 channel 的协程占有的资源无法被 GC 清理最终导致内存泄露。

channle 方便 golang 程序使用 CSP 的编程范形，但是 golang 是一种多范形的编程语言，golang 也支持传统的通过共享内存来通信的编程方式。终极的原则是根据场景选择合适的编程范型，不要因为 channel 好用而滥用 CSP 。

网站栏目：Golang channel 使用总结
分享地址：http://www.shufengxianlan.com/qtweb/news0/462100.html

成都网站建设公司_创新互联，为您提供搜索引擎优化、移动网站建设、自适应网站、品牌网站制作、面包屑导航、微信小程序

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

网站建设知识

同城分类信息

成都二枢电信服务器托管　　 　玄科环保　　 　企业网站建设　　 　app开发公司　　 　网站设计　　 　成都名片印刷　　 　大橙子建站　　 　云南护栏打桩机　　 　四川成都托管服务器　　 　网站推广营销　　 　网络推广　　 　重庆网站设计　　 　网站开发　　 　营销网站定位　　 　眉山托管服务器　　 　小程序　　 　成都网站设计　　 　网站设计公司　　 　app制作　　 　等级保护测评