go goroutine 和 channel（一）

Go 有2种并发风格，一种是由 goroutine 和 通道 支持的通信顺序进程（Communicating Sequential Processes，CSP），其思想是

goroutine

在Go里，每一个并发执行的活动称之为 goroutine，当一个程序启动时，只有一个来调用 main函数，称它为主goroutine，新的通过go语句进行创建。

f()      // 调用f，等待返回
go f()   // 新建1个调用f()的goroutine，不用等待

main 函数返回时，所有的 goroutine 都暴力地直接终结，然后程序退出。

channel

channel是让一个goroutine发送特定的值到另一个goroutine的通信机制，每一个channel是一个具体类型的导管。

ch := make(chan int)  // ch 通道元素类型是int

和 map 一样，通道是一个使用 make创建的数据结构的引用。

通道主要操作：发送（写），接收（读）

ch <- x   // 发送语句

<-ch      // 接收语句，丢弃结果
x = <-ch  // 赋值语句的中的接收表达式 

通道还支持的操作是关闭：

close(ch)

在一个关闭后的通道上发送（写）将会导致宕机
在一个关闭后的通道上进行接收（读）操作，将会获取所有已经发送的值，直到通道为空，然后接收的数据是元素类型的零值。

x, ok := <-ch  // 返回2个值的接受表达式，

第一个变量表示读出的数据，第二个变量表示是否成功读取了数据，需要注意的是，第二个变量并不能用于指示通道的关闭状态。它表示的应该是通道中是否有数据，因为一个关闭的通道有2种情况：
1、通道缓冲区中已经没有数据，此时第一个为类型相应的零值，第二个为false
2、通道缓冲区还有数据，此时第一个为读取到的数据，第二个为true

• nil 通道

  var a chan int   // nil 通道
  

  读写 nil通道，都会被阻塞。

• 对channel 的遍历

   c := make(chan string, 2)
   c <- "hello"
   c <- "world"
  
   time.AfterFunc(time.Microsecond, func() {
       close(c)
   }
  
   for e := range c {
       fmt.Printf("element: %s\n", e)
   }
  

  range 会阻塞等待 channel 中的数据，直到 channel 被关闭；
  同时，如果 range 作用域值为 nil 的 channel 时，则会永久阻塞。

无缓冲通道

无缓冲通道上的 goroutine 发送操作将会阻塞，直到另一个 goroutine 在对应的通道上执行接收操作，这时值传送完成，两个 goroutine 都可以继续执行。
相反，如果接收操作先执行，接收方将会阻塞，直到发送方另一个在通道上发送一个值。

使用无缓冲通道进行通信导致发送和接收的同步化，无缓冲通道也称为同步通道。

• 事件

  func main() {
      exit := make(chan struct{})
    
      go func() {
          println("hello world")
          exit <- struct{}{}
      }
  
      <-exit
      println("end.")
  }
  

• 管道
  通道可以用来连接goroutine，这样一个的输出可以是另一个的输入，这样的模式叫作管道

  func main() {
      naturals := make(chan int)
      squares := make(chan  int)
      
      go func() {
          for x := 0; ; x++ {
              naturals <- x
          }
      }
      
      go func() {
          for {
              x := <-naturals 
              naturals <- x * x
          }
      }
      
      for {
          fmt.Println(<-squares)
      }      
  }
  

• 单向通道

有缓冲通道

有缓冲通道有1个缓冲队列，队列的最大长度在创建的时候通过make的容量参数来设置。

ch = make(chan int, 5)

7304940-80e251ecd90d1ab6.jpg

缓冲通道上的发送操作在队列的尾部插入一个元素，接收操作从头部移除一个元素，如果通道满了，发送操作将会阻塞所在的 goroutine 直到另一个 goroutine 对它进行接收操作来留出可用的空间。
反过来，如果通道是空的，执行接收操作的将会阻塞。

ch <- "A"
ch <- "B"
ch <- "C"
ch <- "D" // 此时通道是满的，将会导致发送的goroutine阻塞，直到另一个goroutine接收
fmt.Println(<-ch);  // 接收

使用内置函数cap可以知道缓冲区的容量

fmt.Println(cap(ch));

使用内置函数len可以获取当前通道内的元素个数

fmt.Println(len(ch));