Go 语言学习笔记-Goroutine和channel

Goroutine

什么是 Goroutine

Goroutine 是 Go 并行设计的核心。Goroutine 说到底其实就是协程，它比线程更小，十几个 Goroutine 可能体现在地城就是五六个线程，Go 语言内部实现了这些 Goroutine 之间的内存共享。

执行 Goroutine 只需极少的栈内存（大概是 4~5KB），会根据相应的数据伸缩。也正因为如此，可同时运行成千上万个并发任务。Goroutine 比 thread 更易用、更高效、更轻便。

Goroutine 的创建

只需要在函数调用语句前添加 go 关键字，就可创建并发执行单元。开发人员无需了解任何执行细节，调度器会自动将其安排到合适的系统线程上执行。

Goroutine 的特征

主 go 程结束，子 go 程随之退出。

示例

package main

import (
    "fmt"
    "time"
)

func sing() {
    for i := 0; i < 50; i++ {
        fmt.Println("----我正在唱歌----")
        time.Sleep(100 * time.Millisecond)
    }
}

func dance() {
    for i := 0; i < 50; i++ {
        fmt.Println("----我正在跳舞----")
        time.Sleep(100 * time.Millisecond)
    }
}

func main() {
  // 子 go 程
    go sing()
    go dance()

  // 主 go程循环打印
    for {
        ;
    }
}

程序运行结果：

go程示例.png

runtime 包

• Gosched

  runtime.Gosched() 用于让出 CPU 时间片，让出当前 goroutine 的执行权限，调度器安排其他等待的任务运行，并在下次再获得 CPU 时间轮片的时候，从该处让 CPU 的位置恢复执行。 ---时间片轮传调度算法

• Goexit

  调用 runtime.Goexit() 将立即终止当前 goroutine 执行，调度器确保所有已注册 defer 延迟调用被执行。

  • return：返回当前函数调用到调用者那里去。return 之前的 defer 注册生效。
  • Goexit()：结束调用该函数的当前 go 程。Goexit() 之前注册的 defer 都生效。

• GOAMAXPROCS

  调用 runtime.GOMAXPROCS()，用来设置可以并行计算的 CPU 核数的最大值，返回返回之前的值。首次调用返回默认值。

• 补充

  • 每当有一个进程启动时，系统会自动打开三个文件：标准输入、标准输出、标准错误。 ---对应三个文件：stdin、stdout、stderr。

  • 当进程运行结束，操作系统自动关闭三个文件。

channel

• channel 是 Go 语言中的一个 核心类型，可以把它看成管道（通道 FIFO）。并发核心单元通过它就可以发送或者接收数据进行通讯。

• channel 是一个数据类型，只要用来解决协程的同步问题以及协程之间数据共享（数据传递）的问题。

• goroutine 运行在相同的地址空间，因此访问共享内存必须做好同步。goroutine 奉行通过通信来共享内存，而不是共享内存来通信

• 引用类型 channel 可用于多个 goroutine 通讯。其内部实现了同步，确保并发安全。

goroutine.jpg

定义 channel 变量

chan 是创建 channel 所需使用的关键字。Type 代表指定 channel 手法数据的类型。

make(chan Type)     // 等价于 make(chan Type, 0)
make(chan Type, capacity)

和 map 类似，channel 也是一个对应 make 创建的底层数据结构的引用。

和其它的引用类型一样，channel 的零值也是 nil。

赋值 channel 或者用于函数参数传递，都是使用的 channel 的引用。

当阐述 capacity = 0 时，channel 是无缓冲阻塞读写的；当 capacity > 0 时，channel 有缓冲、是非阻塞的，直到写满 capacity 个元素才阻塞写入。

channel 非常像生活中的管道，一边可以存放东西，另一边可以取出东西。channel 通过操作符 <- 来接收和发送数据：

channel := make(chan int)
channel <- value        // 写端（传入端）：发送 value 到 channel
x := <- channel         // 读端（传出端）：从 channel 中接收数据，并赋值给 x
x, ok := <- channel     // 功能同上，同时检查通道是否已关闭或者是否为空

默认情况下，channel 接收和发送数据都是阻塞的，除非另一端已经准备好，这样就使得 goroutine 同步变得更加简单，而不需要显示 lock。

无缓冲 channel

make(chan Type)     // 等价于 make(chan Type, 0)

无缓冲的通道（unbuffered channel）：是指在接收前没有能力保存任何值的通道。

如果没有指定缓冲区容量，那么该通道就是同步的，因此会阻塞到发送者准备好发送和接收者准备好接收，才解除阻塞。

无缓冲的goroutine.png

有缓冲 channel

make(chan Type, capacity)       // capacity > 0

有缓冲的通道（buffered channel）是一种在被接收前能存储一个或者多个数据值的通道。

• 这种类型的通道并不强制要求 goroutine 之间必须同时完成发送和接收。通道会阻塞发送和接收动作的条件也不同。
  • 只要通道中没有要接收的值时，接收动作才会阻塞。
  • 只要通道没有可用缓冲区容纳被发送的值时，发送动作才会阻塞。

如果给定一个缓冲区容量，通道就是异步的。只要缓冲区有未使用空间用于发送数据，或还包含可以接收的数据，那么其通信就会无阻塞的进行。

有缓冲的goroutine.png

有缓冲和无缓冲 channel 的区别

• 无缓冲的通道保证进行发送和接收的 goroutine 会在同一时间进行数据交换；有缓冲的通道没有这种保证。

关闭 channel

如果发送者知道，没有更多的值要发送到 channel 的话，那么有必要让接收者也能及时知道没有多余的值可接受，因此接收者可以停止不必要的接收等待。可以通过内置的 close() 函数来关闭 channel。

package main

import (
    "fmt"
)

func main() {
    c := make(chan int)

    go func() {
        for i := 0; i < 5; i++ {
            c <- i
        }
        //把 close(c) 注释掉，程序会一直阻塞在 if data, ok := <-c; ok 那一行
        close(c)
    }()

    for {
        //ok为true说明channel没有关闭，为false说明管道已经关闭
        if data, ok := <-c; ok {
            fmt.Println(data)
        } else {
            break
        }
        }
        
        // 可以使用 range 来迭代不断操作 channel
        // for data := range c {
    //     fmt.Println(data)
    // }

    fmt.Println("Finished")
}

注意

• channel 不像文件一样需要经常去关闭，只有当你确实没有任何发送数据了，或者你想显示的结束 range 循环之类的，才去关闭 channel
• 关闭 channel 后，无法向 channel 再发送数据（引发 panic 错误后导致接收立即返回零值）
• 关闭 channel 后，可以继续从 channel 接收数据
• 对于 nil channel，无论收发都会被阻塞。

单向 channel 及应用

默认情况下，通道 channel 是双向的。也就是，既可以往里面发送数据，也可以从里面接收数据。

但是，我们经常见一个通道作为参数进行传递而只希望对方是单向使用的，要么只让它发送数据，要么只让它接收数据，这时候我们可以指定通道的方向

channel.png

var ch1 chan int    // ch1 是一个正常的 channel，是双向的
var ch2 chan<- float64  // ch2 是单向的 channel，只用于写 float64 数据
var ch3 <-chan int      // ch3 是单向 channel，只用于读 int 数据

• chan <-：表示数据进入管道，要把数据写进管道，对于调用者就是输出。
• <- chan：表示数据从管道出来，对于调用者就是得到管道的数据，就是输入。

可以将 channel 隐式转换为单向队列，只收或者只发，不能将单向 channel 转换为普通 channel：

ch := make(chan int, 3)
var send chan<- int = ch    // send-only
var recv <-chan int = ch    // receive-only
send <- 1
//<-send //invalid operation: <-send (receive from send-only type chan<- int)
<-recv
//recv <- 2 //invalid operation: recv <- 2 (send to receive-only type <-chan int)

//不能将单向 channel 转换为普通 channel
d1 := (chan int)(send) //cannot convert send (type chan<- int) to type chan int
d2 := (chan int)(recv) //cannot convert recv (type <-chan int) to type chan int