Go协程并发信道

Posted 2021-03-12 ExplorerMan

Go 通过协程实现并发，协程之间靠信道通信

1.1 并发、并行是什么？

• 并行其实很好理解，就是同时执行的意思，在某一时间点能够执行多个任务。
  想达到并行效果，最简单的方式就是借助多线程或多进程，这样才可在同一时刻执行多个任务。单线程是永远无法达到并行状态的。例，"合作并行开发某个项目"
• 并发是在某一时间段内可以同时处理多个任务。我们通常会说程序是并发设计的，也就是说它允许多个任务同时执行，这个同时指的就是一段时间内。单线程中多个任务以间隔执行实现并发。例，我边听歌边写代码。

并行是指两个或者多个事件在同一时刻发生；而并发是指两个或多个事件在同一时间间隔内发生。

多线程或多进程是并行的基础，但单线程也通过协程实现了并发。

1.2 go协程是什么？

Go 协程是与其他函数或方法一起并发运行的函数或方法。Go 协程可以看作是轻量级线程。与线程相比，创建一个 Go 协程的成本很小。因此在 Go 应用中，常常会看到有数以千计的 Go 协程并发地运行。
Go 创建一个协程非常简单，只要在方法或函数调用之前加关键字 go 即可。

// 匿名协程
go func(){
}

1.3 Go 协程相比于线程的优势

• 相比线程而言，Go 协程的成本极低。堆栈大小只有若干 kb，并且可以根据应用的需求进行增减。而线程必须指定堆栈的大小，其堆栈是固定不变的。
• Go 协程会复用（Multiplex）数量更少的 OS 线程。即使程序有数以千计的 Go 协程，也可能只有一个线程。如果该线程中的某一 Go 协程发生了阻塞（比如说等待用户输入），那么系统会再创建一个 OS 线程，并把其余 Go 协程都移动到这个新的 OS 线程。所有这一切都在运行时进行，作为程序员，我们没有直接面临这些复杂的细节，而是有一个简洁的 API 来处理并发。
• Go 协程使用信道（Channel）来进行通信。信道用于防止多个协程访问共享内存时发生竞态条件（Race Condition）。信道可以看作是 Go 协程之间通信的管道。

1.4 信道

1.4.1 声明信道

var c chan int          // 方式一，为nil，不能发送也不能接受数据
c := make(chan int)    // 方式二，可用

channel底层实现参考
channel是一个带缓冲，包含两个双向链表，分别是接受，发送消息。

1.4.2 信道使用[无缓冲信道]

c := make(chan int) // 写数据
c <- data

// 读数据
variable <- c  // 方式一
<- c              // 方式二,读出来的数据丢弃不使用

信道操作默认是阻塞的，往信道里写数据之后当前协程便阻塞，直到其他协程将数据读出。
一个协程被信道操作阻塞后，Go 调度器会去调用其他可用的协程，这样程序就不会一直阻塞。

func printHello(c chan bool) {
     fmt.Println("hello world goroutine")
     <- c    // 读取信道的数据
 }

 func main() {
     c := make(chan bool)
     go printHello(c)
     c <- true    // main 协程阻塞
    fmt.Println("main goroutine")

输出

hello world goroutine
main goroutine

1.4.3 死锁

前面提到过，读/写数据的时候信道会阻塞，调度器会去调度其他可用的协程。问题来了，如果没有其他可用的协程会发生什么情况？没错，就会发生著名的死锁。
最简单的情况就是，只往信道写数据。只读不写也会报同样的错误。

fatal error: all goroutines are asleep - deadlock!

1.4.4 关闭信道与 for loop

val, ok := <- channel
val 是接收的值，ok 标识信道是否关闭。为 true 的话，该信道还可以进行读写操作；为 false 则标识信道关闭，数据不能传输。
使用内置函数 close() 关闭信道。

使用 for range 读取信道，信道关闭，for range 自动退出。
使用 for range 一个信道，发送完毕之后必须 close() 信道，不然发生死锁。

func printNums(ch chan int) {
     for i := 0; i < 4; i++ {
         ch <- i
     }
     close(ch)
 }

 func main() {
     ch := make(chan int)
    go printNums(ch)

    for v := range ch {
        fmt.Println(v)
    }
}

输出

1   0
2   1
3   2
4   3

1.4.5 缓冲信道和信道容量

func main() {
     ch := make(chan int,3)

     ch <- 7
     ch <- 8
     ch <- 9
     //ch <- 10
     // 注释打开的话，协程阻塞，发生死锁
     会发生死锁：信道已满且没有其他可用信道读取数据

    fmt.Println("main stopped")
}

1.4.6 单向信道

之前创建的都是双向信道，既能发送数据也能接收数据。我们还可以创建单向信道，只发送或者只接收数据。
语法：

rch 是只发送信道，sch 是只接受信道。

rch := make(<-chan int)
sch := make(chan<- int)

这种单向信道有什么用呢？我们总不能只发不接或只接不发吧。这种信道主要用在信道作为参数传递的时候，Go 提供了自动转化，双向转单向

1.4.7 注意

链接参见

读写nil通道都会死锁

// 读nil通道:

var dataStream chan interface{}

<-dataStream

// 写nil通道:

var dataStream chan interface{}

dataStream <- struct{}{}

//都会死锁:

fatal error: all goroutines are asleep - deadlock!

close 值为nil的channel会panic:

var dataStream chan interface{}

close(dataStream)

panic: close of nil channel

1.4.8 Select

select 可以安全的将channels与诸如取消、超时、等待和默认值之类的概念结合在一起。
select看起来就像switch 包含了很多case,然而与switch不同的是：select块中的case语句没有顺序地进行测试，如果没有满足任何条件，执行不会自动失败,如果同时满足多个条件随机执行一个case。
类似witch
1、case分支中必须是一个IO操作：
2、当case分支不满足监听条件，阻塞当前case分支
3、如果同时有多个case分支满足，select随机选定一个执行（select底层实现，case对应一个Goroutine），
4、一次select监听，只能执行一个case分支，未执行的分支将被丢弃。通常将select放于for循环中。
5、default在所有case均不满足时，默认执行的分组，为了防止忙轮询，通常将for中select中的default省略。

【结论】使用select的Goroutine，与其他Goroutine间才用异步通信。