go goroutine 和 channel

Go 有2种并发风格，一种是由 goroutine 和通道支持的通信顺序进程（Communicating Sequential Processes，CSP），其核心思想是：不要通过共享内存来通信，而要通过通信来实现内存共享，实现是两个独立的并发实体通过共享的通讯 channel（管道）进行通信。

goroutine

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

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

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

func main() {
    go func() {
        // .... 
    }()
}

上面的 go func 中的函数可能还没来得及执行完，main 协程就退出了。

channel

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

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

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

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

ch <- x   // 发送语句

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

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

close(ch)

在一个关闭后的通道上发送（写）将会导致 panic
在一个关闭后的通道上进行接收（读）操作，将会获取所有已经发送的值，直到通道为空，此时接收的数据是元素类型的零值。
```
x, ok := <-ch  // 返回2个值的接受表达式，
```
第一个变量表示读出的数据，第二个变量表示是否成功读取了数据。

需要注意的是，第二个变量并不能用于指示通道的关闭状态，它表示的应该是通道中是否有数据，因为一个关闭的通道有2种情况：
- 通道缓冲区中已经没有数据，此时第一个为类型相应的零值，第二个为 false
- 通道缓冲区还有数据，此时第一个为读取到的数据，第二个为 true
在一个关闭后的通道上执行关闭，将会导致panic

nil channel

var a chan int   // nil channel

读写 nil channel ，都会被阻塞。

无缓冲 channel

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

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

应用1：事件通知

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

    <-exit
    println("end.")
}

应用2：管道模型
通道可以用来连接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)
    }      
}

有缓冲 channel

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

ch = make(chan int, 5)

7304940-80e251ecd90d1ab6.jpg

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

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

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

fmt.Println(cap(ch));

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

fmt.Println(len(ch));

示例：用有缓冲 channel 实现生产者消费者模型

package main

import (
    "fmt"
    "time"
)

func Producer(factor int, out chan<- int) {
    for i := 0; ; i++ {
        out <- i * factor
    }
}

func Consumer(in <-chan int) {
    for v := range in {
        fmt.Println(v)
    }
}

func main() {
    ch := make(chan int, 64)
    go Producer(3, ch)
    go Consumer(ch)

    time.Sleep(time.Second * 10)
}

通道操作总结

image.png

go for range 循环和 channel

range 作用于 channel 时，会返回 channel 中所有的元素，如果 channel 中没有元素，则会阻塞等待，直到 channel 被关闭。

func main() {
    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)
    }
}

输出：