关于golang:协程-以及进程和线程

背景与场景

在 Golang 语言学习中，对协程的了解必不可少。仿佛咱们是通过 Golang 才晓得了“协程”的概念，不过协程并不只存在于 Golang 中，是一个由来已久的设计。据 Knuth（计算机界最驰名大佬之一）说，1958 年 Melvin Conway 就提出了协程的概念，且曾经被广泛应用于典型的重量级语言 C#，Erlang，Golang；以及各种轻量级语言 python，lua，JavaScript，ruby；包含函数式语言 scala，scheme。相比于 2007 年才开始设计的 Golang，曾经属于爷爷辈技术了。

当初的协程被设计用于实现合作式的多任务，又被形象地称为“用户态线程”（这和它背地的实现密切相关）。常见的利用场景包含实现状态机，实现并发的“演员模型”（通常被用在制作游戏中），实现生成器，实现通信程序过程等。

协程定义

回到协程的定义，协程，coroutine，cooperation routine，合作的例程，维基百科的定义为：通过生成灵便的挂起和复原的子例程，以实现合作式多任务（非抢占式多任务）的一类计算机程序组件。

在这个定义中，有必要廓清一下“子例程”，subroutine 的概念，同样来自维基百科定义，子例程是计算机编程中用于实现一组特定工作的编程指令。与整个程序相比，它有比拟显著的独立性和内聚性，函数，过程，办法都能够是一类子例程，更相熟的名词是子程序，一种高级语言中的概括性术语。

通过伪代码定义一个简略的协程，如下所示：

# producer coroutine
loop
while queue is not full
  create some new items
  add the items to queue
yield to consumer
 
# consumer coroutine
loop
while queue is not empty
  remove some items from queue
  use the items
yield to producer

两个协程，生产者和消费者，生产者产生商品放入队列，而后通过“yield”告诉消费者。消费者从队列中拿出商品并耗费，再“yield”生产者。就这样两组程序互相合作，在失当的机会让出 CPU 的代码执行权，默契敌对。

那在 Go 语言中，又是如何利用协程的呢？Go 中协程术语为 Goroutine，应用关键字“go”来启动。Go by Example 的例子如下：

package main
 
import (
    "fmt"
    "time"
)
 
func f(from string) {
    for i := 0; i < 3; i++ {fmt.Println(from, ":", i)
    }
}
 
func main() {f("direct")
 
    go f("goroutine")
 
    go func(msg string) {fmt.Println(msg)
    }("going")
 
    time.Sleep(time.Second)
    fmt.Println("done")
}

和过程，线程的比照，以及纤程

咱们比拟相熟的是过程和线程的概念，协程与之有什么区别呢？首先回顾一下：

过程：指计算机中已执行的程序，是操作系统资源调度的根本单位，在明天这个多核时代，过程已不再是执行的根本单位，转而变为了线程的容器。

线程：操作系统可能进行运算调度的最小单位，一个过程能够并发多个线程，多线程在多核 CPU 中能够并行执行不同的工作。

过程的概念应该很容易区别，那么线程和协程之间的区别是什么呢？咱们在协程定义中能够很明确地看到：协程是非抢占式多任务，而线程就是典型的抢占式多任务。理论实现中，一个线程也能够领有多个协程，协程是一种用户级线程的实现。

也有一种说法将协程称作纤程（Fiber），查阅了一下材料，纤程仿佛是存在于 Windows 中的类比协程的概念。这里不再开展。

如何工作

怎么了解协程的“非抢占式”，和“用户级”呢？这里略微回顾一下操作系统相干的常识：

首先看一下过程切换时，操作系统在干什么：

过程是操作系统中资源调度的根本单位，不同过程间资源不共享，最要害的资源就是共享内存。因而在进行过程切换时必须进行内存内数据的切换，也就是咱们常说的“过程上下文切换”。例如 A 过程切换到 B 过程，中断产生时：

• 首要的就是把通用寄存器中所有的数据保留到 A 过程的内核栈中，尤其是 PC（程序计数器），指向了以后程序运行的中央。
• 进行地址空间切换，过程能看到的是一套虚拟内存地址，理论映射向实在的物理地址。切换地址空间也就是把将运行的过程地址空间存入到非凡的页表基址寄存器中。
• 进行硬件上下文切换，复原过程 B 的各类寄存器状态，好像回到了过程 B 上次中断退出前的状态。

在这个过程中，对于各种寄存器的保留复原等都会进入操作系统的内核空间进行。

而在线程切换时，又分为内核线程和用户线程切换。

• 对于内核线程，不须要切换地址空间，因为所有工作共享内核地址空间。
• 对于用户线程，则会辨别切换前后两个线程是否属于同一个过程，如果是同一个过程共享地址空间的状况下，同样不须要切换地址空间。不同过程下的线程则会走残缺的过程切换过程。
• 须要留神的是，即便是同过程下的线程切换，调度过程依然会触发中断，波及到用户态与内核态之间的转换。过程中会做线程上下文的切换。

对于协程呢？

• 首先，协程的上下文（函数栈状态和寄存器的值）是间接放在堆中的。（有待从更权威的材料确认各语言的实现形式）
• 其次，协程须要被动让出 CPU 控制权，也就是执行 yield，这个动作在不同语言中有不同的实现办法。
• 这两点保障了协程的切换由程序员掌控，而非通过零碎中断，也就因而不须要进入内核态，节俭了切换开销。

劣势与劣势

过程切换最大的开销在于刷新页表，会大抵大量的 cache miss，同时还会进行内核态用户态切换。而同过程的线程切换躲避了地址空间的切换开销，但内核态与用户态的切换依然破费了不少工夫。协程切换防止了进入内核态，但如何施展这个劣势依然须要留神。依据大家的总结：

1. 计算密集型的程序频繁应用协程切换并没有太大意义，此时的切换更加相似于函数调用。来回切换还须要保留协程状态，升高性能。
2. IO 性操作则能够充分利用 IO wait 工夫进行协程切换晋升并发，实现异步编程。

当然如果协程调用了阻塞 IO，无奈被动进行切换，那么操作系统依然会执行线程切换。无效的应用场景是让协程在 IO 等待时间切换执行工作，当 IO 操作完结后再主动回调，协程 + 异步能施展最大作用。协程也成为了用同步写法写异步代码的一种良好实际。

作为实际，能够参考一下 Python 中代码的例子：

async def main():
    task1 = asyncio.create_task(say_after(1, 'hello'))
 
    task2 = asyncio.create_task(say_after(2, 'world'))
 
    print(f"started at {time.strftime('%X')}")
 
    # Wait until both tasks are completed (should take
    # around 2 seconds.)
    await task1
    await task2
 
    print(f"finished at {time.strftime('%X')}")

task1 会期待 1 秒后输入 hello，task2 会期待 2s 后输入 world，asynio.create_task 会创立协程异步操作，整个程序执行完的工夫是 2s。

参考资料

• https://en.wikipedia.org/wiki…
• https://zh.wikipedia.org/wiki/Go
• https://coolshell.cn/articles…
• https://zhuanlan.zhihu.com/p/…
• https://cloud.tencent.com/dev…
• https://cloud.tencent.com/dev…
• https://www.jianshu.com/p/4af…