Go协程、并发、信道

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间才用异步通信。

你可能感兴趣的:(Go协程、并发、信道)