大家好，我是易安！明天咱们来探讨一个问题，Go 协程的实现原理。此“协程”非彼”携程“。
线程实现模型
讲协程之前，咱们先看下线程的模型。
实现线程次要有三种形式：轻量级过程和内核线程一对一互相映射实现的1:1线程模型、用户线程和内核线程实现的N:1线程模型以及用户线程和轻量级过程混合实现的N:M线程模型。
1:1线程模型
以上我提到的内核线程（Kernel-Level Thread, KLT）是由操作系统内核反对的线程，内核通过调度器对线程进行调度，并负责实现线程的切换。
咱们晓得在Linux操作系统编程中，往往都是通过fork()函数创立一个子过程来代表一个内核中的线程。一个过程调用fork()函数后，零碎会先给新的过程分配资源，例如，存储数据和代码的空间。而后把原来过程的所有值都复制到新的过程中，只有多数值与原来过程的值（比方PID）不同，这相当于复制了一个主过程。
采纳fork()创立子过程的形式来实现并行运行，会产生大量冗余数据，即占用大量内存空间，又耗费大量CPU工夫用来初始化内存空间以及复制数据。
如果是一份一样的数据，为什么不共享主过程的这一份数据呢？这时候轻量级过程（Light Weight Process，即LWP）呈现了。
绝对于fork()零碎调用创立的线程来说，LWP应用clone()零碎调用创立线程，该函数是将局部父过程的资源的数据结构进行复制，复制内容可选，且没有被复制的资源能够通过指针共享给子过程。因而，轻量级过程的运行单元更小，运行速度更快。LWP是跟内核线程一对一映射的，每个LWP都是由一个内核线程反对。
N:1线程模型
1:1线程模型因为跟内核是一对一映射，所以在线程创立、切换上都存在用户态和内核态的切换，性能开销比拟大。除此之外，它还存在局限性，次要就是指零碎的资源无限，不能反对创立大量的LWP。
N:1线程模型就能够很好地解决1:1线程模型的这两个问题。
该线程模型是在用户空间实现了线程的创立、同步、销毁和调度，曾经不须要内核的帮忙了，也就是说在线程创立、同步、销毁的过程中不会产生用户态和内核态的空间切换，因而线程的操作十分疾速且低消耗。
N:M线程模型
N:1线程模型的毛病在于操作系统不能感知用户态的线程，因而容易造成某一个线程进行零碎调用内核线程时被阻塞，从而导致整个过程被阻塞。
N:M线程模型是基于上述两种线程模型实现的一种混合线程治理模型，即反对用户态线程通过LWP与内核线程连贯，用户态的线程数量和内核态的LWP数量是N:M的映射关系。
理解完这三个线程模型，你就能够分明地理解到Go的协程实现与Java线程的实现有什么区别了。
JDK 1.8 Thread.java 中 Thread start 办法的实现，实际上是通过Native调用start0办法实现的；在Linux下， JVM Thread的实现是基于pthread\_create实现的，而pthread\_create实际上是调用了clone()实现零碎调用创立线程的。
所以，目前Java在Linux操作系统下采纳的是用户线程加轻量级线程，一个用户线程映射到一个内核线程，即1:1线程模型。因为线程是通过内核调度，从一个线程切换到另一个线程就波及到了上下文切换。
而Go语言是应用了N:M线程模型实现了本人的调度器，它在N个内核线程上多路复用（或调度）M个协程，协程的上下文切换是在用户态由协程调度器实现的，因而不须要陷入内核，相比之下，这个代价就很小了。
协程的实现原理
协程不只在Go语言中实现了，其实目前大部分语言都实现了本人的一套协程，包含C#、erlang、python、lua、javascript、ruby等。
绝对于协程，你可能对过程和线程更为相熟。过程个别代表一个应用服务，在一个应用服务中能够创立多个线程，而协程与过程、线程的概念不一样，咱们能够将协程看作是一个类函数或者一块函数中的代码，咱们能够在一个主线程外面轻松创立多个协程。
程序调用协程与调用函数不一样的是，协程能够通过暂停或者阻塞的形式将协程的执行挂起，而其它协程能够继续执行。这里的挂起只是在程序中（用户态）的挂起，同时将代码执行权转让给其它协程应用，待获取执行权的协程执行实现之后，将从挂终点唤醒挂起的协程。 协程的挂起和唤醒是通过一个调度器来实现的。
联合下图，你能够更分明地理解到基于N:M线程模型实现的协程是如何工作的。
假如程序中默认创立两个线程为协程应用，在主线程中创立协程ABCD…，别离存储在就绪队列中，调度器首先会调配一个工作线程A执行协程A，另外一个工作线程B执行协程B，其它创立的协程将会放在队列中进行排队期待。
当协程A调用暂停办法或被阻塞时，协程A会进入到挂起队列，调度器会调用期待队列中的其它协程抢占线程A执行。当协程A被唤醒时，它须要从新进入到就绪队列中，通过调度器抢占线程，如果抢占胜利，就继续执行协程A，失败则持续期待抢占线程。
相比线程，协程少了因为同步资源竞争带来的CPU上下文切换，I/O密集型的利用比拟适宜应用，特地是在网络申请中，有较多的工夫在期待后端响应，协程能够保障线程不会阻塞在期待网络响应中，充分利用了多核多线程的能力。而对于CPU密集型的利用，因为在少数状况下CPU都比拟忙碌，协程的劣势就不是特地显著了。
Kilim协程框架
尽管这么多的语言都实现了协程，但目前Java原生语言临时还不反对协程。不过你也不必气馁，咱们能够通过协程框架在Java中应用协程。
目前Kilim协程框架在Java中利用得比拟多，通过这个框架，开发人员就能够低成本地在Java中应用协程了。
在Java中引入 Kilim ，和咱们平时引入第三方组件不太一样，除了引入jar包之外，还须要通过Kilim提供的织入（Weaver）工具对Java代码编译生成的字节码进行加强解决，比方，辨认哪些形式是可暂停的，对相干的办法增加上下文解决。通常有以下四种形式能够实现这种织入操作：
- 在编译时应用maven插件；
- 在运行时调用kilim.tools.Weaver工具；
- 在运行时应用kilim.tools.Kilim invoking调用Kilim的类文件；
- 在main函数增加 if (kilim.tools.Kilim.trampoline(false,args)) return。
Kilim框架蕴含了四个外围组件，别离为：工作载体（Task）、工作上下文（Fiber）、任务调度器（Scheduler）以及通信载体（Mailbox）。
Task对象次要用来执行业务逻辑，咱们能够把这个比作多线程的Thread，与Thread相似，Task中也有一个run办法，不过在Task中办法名为execute，咱们能够将协程外面要做的业务逻辑操作写在execute办法中。
与Thread实现的线程一样，Task实现的协程也有状态，包含：Ready、Running、Pausing、Paused以及Done总共五种。Task对象被创立后，处于Ready状态，在调用execute()办法后，协程处于Running状态，在运行期间，协程能够被暂停，暂停中的状态为Pausing，暂停后的状态为Paused，暂停后的协程能够被再次唤醒。协程失常完结后的状态为Done。
Fiber对象与Java的线程栈相似，次要用来保护Task的执行堆栈，Fiber是实现N:M线程映射的要害。
Scheduler是Kilim实现协程的外围调度器，Scheduler负责分派Task给指定的工作者线程WorkerThread执行，工作者线程WorkerThread默认初始化个数为机器的CPU个数。
Mailbox对象相似一个邮箱，协程之间能够依附邮箱来进行通信和数据共享。协程与线程最大的不同就是，线程是通过共享内存来实现数据共享，而协程是应用了通信的形式来实现了数据共享，次要就是为了防止内存共享数据而带来的线程平安问题。
协程与线程的性能比拟
接下来，咱们通过一个简略的生产者和消费者的案例，来比照下协程和线程的性能。
Java多线程实现源码：
public class MyThread {
private static Integer count = 0;//
private static final Integer FULL = 10; //最大生产数量
private static String LOCK = "lock"; //资源锁
public static void main(String[] args) {
MyThread test1 = new MyThread();
long start = System.currentTimeMillis();
List<Thread> list = new ArrayList<Thread>();
for (int i = 0; i < 1000; i++) {//创立五个生产者线程
Thread thread = new Thread(test1.new Producer());
thread.start();
list.add(thread);
}
for (int i = 0; i < 1000; i++) {//创立五个消费者线程
Thread thread = new Thread(test1.new Consumer());
thread.start();
list.add(thread);
}
try {
for (Thread thread : list) {
thread.join();//期待所有线程执行完
}
} catch (InterruptedException e) {
e.printStackTrace();
}
long end = System.currentTimeMillis();
System.out.println("子线程执行时长：" + (end - start));
}
//生产者
class Producer implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (LOCK) {
while (count == FULL) {//当数量满了时
try {
LOCK.wait();
} catch (Exception e) {
e.printStackTrace();
}
}
count++;
System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + count);
LOCK.notifyAll();
}
}
}
}
//消费者
class Consumer implements Runnable {
public void run() {
for (int i = 0; i < 10; i++) {
synchronized (LOCK) {
while (count == 0) {//当数量为零时
try {
LOCK.wait();
} catch (Exception e) {
}
}
count--;
System.out.println(Thread.currentThread().getName() + "消费者生产，目前总共有" + count);
LOCK.notifyAll();
}
}
}
}
}
Kilim协程框架实现源码：
public class Coroutine {
static Map<Integer, Mailbox<Integer>> mailMap = new HashMap<Integer, Mailbox<Integer>>();//为每个协程创立一个信箱，因为协程中不能多个消费者共用一个信箱，须要为每个消费者提供一个信箱，这也是协程通过通信来保障共享变量的线程平安的一种形式
public static void main(String[] args) {
if (kilim.tools.Kilim.trampoline(false,args)) return;
Properties propes = new Properties();
propes.setProperty("kilim.Scheduler.numThreads", "1");//设置一个线程
System.setProperties(propes);
long startTime = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {//创立一千生产者
Mailbox<Integer> mb = new Mailbox<Integer>(1, 10);
new Producer(i, mb).start();
mailMap.put(i, mb);
}
for (int i = 0; i < 1000; i++) {//创立一千个消费者
new Consumer(mailMap.get(i)).start();
}
Task.idledown();//开始运行
long endTime = System.currentTimeMillis();
System.out.println( Thread.currentThread().getName() + "总计破费时长：" + (endTime- startTime));
}
}
//生产者
public class Producer extends Task<Object> {
Integer count = null;
Mailbox<Integer> mb = null;
public Producer(Integer count, Mailbox<Integer> mb) {
this.count = count;
this.mb = mb;
}
public void execute() throws Pausable {
count = count*10;
for (int i = 0; i < 10; i++) {
mb.put(count);//当空间有余时，阻塞协程线程
System.out.println(Thread.currentThread().getName() + "生产者生产，目前总共有" + mb.size() + "生产了：" + count);
count++;
}
}
}
//消费者
public class Consumer extends Task<Object> {
Mailbox<Integer> mb = null;
public Consumer(Mailbox<Integer> mb) {
this.mb = mb;
}
/**
* 执行
*/
public void execute() throws Pausable {
Integer c = null;
for (int i = 0; i < 10000; i++) {
c = mb.get();//获取音讯，阻塞协程线程
if (c == null) {
System.out.println("计数");
}else {
System.out.println(Thread.currentThread().getName() + "消费者生产，目前总共有" + mb.size() + "生产了：" + c);
c = null;
}
}
}
}
在这个案例中，我创立了1000个生产者和1000个消费者，每个生产者生产10个产品，1000个消费者同时生产产品。咱们能够看到两个例子运行的后果如下：
多线程执行时长：2761
协程执行时长：1050
通过上述性能比照，咱们能够发现：在有重大阻塞的场景下，协程的性能更胜一筹。其实，I/O阻塞型场景也就是协程在Java中的次要利用。
总结
协程和线程密切相关，协程能够认为是运行在线程上的代码块，协程提供的挂起操作会使协程暂停执行，而不会导致线程阻塞。
协程又是一种轻量级资源，即便创立了上千个协程，对于零碎来说也不是很大的累赘，但如果在程序中创立上千个线程，那零碎可真就压力山大了。能够说，协程的设计形式极大地提高了线程的使用率。
协程是一种设计思维，不仅仅局限于某一门语言，况且Java曾经能够借助协程框架实现协程了。
但不得不通知你的是，协程还是在Go语言中的利用较为成熟，在Java中的协程目前还不是很稳固，重点是不足大型项目的验证，能够说Java的协程设计还有很长的路要走。
本文由mdnice多平台公布
发表回复