channels

默认情况下，发送和接收操作在另一端准备好之前都会阻塞。这使得 Go 程可以在没有显式的锁或竞态变量的情况下进行同步。

  1. 使用前必须被创建

    c := make(chan int)

  2. 可以指定缓冲区大小

    cc := make(chan int,2)

  1. package main
  3. import "fmt"
  5. func sum(s []int, c chan int) {
  6.     sum := 0
  7.     for _, v := range s {
  8.         sum += v
  9.     }
  10.     c <- sum
  11. }
  13. func main() {
  14.     s := []int{1, 2, 3, 4, 5}
  15.     //使用前必须创建
  16.     c := make(chan int)
  17.     go sum(s[:len(s)/2], c)
  18.     go sum(s[len(s)/2:], c)
  19.     x, y := <-c, <-c
  20.     fmt.Println(x, y, x+y) //12 3 15
  22.     //使用前可以指定缓冲区大小
  23.     cc := make(chan int, 5)
  24.     cc <- 2
  25.     cc <- 3
  26.     cc <- 4
  27.     fmt.Println(<-cc)
  28.     fmt.Println(<-cc)
  29.     fmt.Println(<-cc)
  30.     // fmt.Println(<-cc)  //fatal error: all goroutines are asleep - deadlock!
  31. }

close，range

close

发送者通过close(c)来关闭信道
而接收者通过

v, ok := <-ch

接收表达式分配的第二个参数来判断是否关闭，如果是false,那么就关闭

  1. package main
  3. import "fmt"
  5. func fibonacci(n int, c chan int) {
  6.     x, y := 0, 1
  7.     for i := 0; i < n; i++ {
  8.         c <- x
  9.         x, y = y, x+y
  10.     }
  11.     close(c)
  12.     // c <- x   //panic: send on closed channel
  13. }
  15. func main() {
  16.     c := make(chan int, 10)
  17.     go fibonacci(cap(c), c)
  18.     for i := range c {
  19.         fmt.Println(i)
  20.     }
  21. }

range

循环 for i := range c 会不断从信道接收值，直到它被关闭。
信道与文件不同，通常情况下无需关闭它们。只有在必须告诉接收者不再有需要发送的值时才有必要关闭，例如终止一个 range 循环
去掉上面程序里的close(c)会输出

0 1 …(中间是斐波拉契数列） 34 fatal error: all goroutines are asleep - deadlock!