协程的概念

分手后的思念是犯贱 2022-01-07 12:07 128阅读 0赞

> 协程内部是线程内容划分的更小的单位，协程跟操作系统没有关系，只是程序员自己划分出来的，类似于一个线程中的一跳主线中的两个函数交替运行，达到同时运行的效果，用**yield关键字**可以让函数暂停下来，**next()函数**可以让程序继续运行，互相配合达到了协程的效果，上下文切换快速，不需要竞争资源，一条主线。

### **概念：** ###

**协程不是进程或线程，其执行过程更类似于子例程**，或者说不带返回值的[函数调用][Link 1]。**是一种比线程更加轻量级的存在。**一个线程也可以拥有多个协程。

一个程序可以包含多个协程，可以对比与一个进程包含多个线程，因而下面我们来比较协程和线程。我们知道多个线程相对独立，有自己的上下文，切换受系统控制；而协程也相对独立，有自己的上下文，但是其切换由自己控制，由当前协程切换到其他协程由当前协程来控制。

**编程语言Lua**从5.0版开始支持协程的概念，极大的扩展了Lua的能力。

### **特点：** ###

看起来协程程序执行有点像多线程，**但协程的特点在于是一个线程执行**，**那和多线程比，协程有何优势？**

最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换，而是由程序自身控制，因此，没有线程切换的开销，和多线程比，线程数量越多，协程的性能优势就越明显。

第二大优势就是不需要多线程的锁机制，因为只有一个线程，也不存在同时写变量冲突，在协程中控制共享资源不加锁，只需要判断状态就好了，所以执行效率比多线程高很多。

因为协程是一个线程执行，那怎么利用多核CPU呢？最简单的方法是多进程+协程，既充分利用多核，又充分发挥协程的高效率，可获得极高的性能。

Python对协程的支持还非常有限，用在**generator中的yield**可以一定程度上实现协程。虽然支持不完全，但已经可以发挥相当大的威力了。

参考 ：[https://www.liaoxuefeng.com/wiki/897692888725344/923057403198272][https_www.liaoxuefeng.com_wiki_897692888725344_923057403198272]

### **再次区别一下进程和线程** ###

进程是什么呢？

直白地讲，进程就是应用程序的启动实例。比如我们运行一个游戏，打开一个软件，就是开启了一个进程。

进程拥有代码和打开的文件资源、数据资源、独立的内存空间。

线程又是什么呢？

线程从属于进程，是程序的实际执行者。一个进程至少包含一个主线程，也可以有更多的子线程。

线程拥有自己的栈空间。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU5Mzk4NQ_size_16_color_FFFFFF_t_70][]

**总而言之，对操作系统来说，线程是最小的执行单元，进程是最小的资源管理单元。**

无论进程还是线程，都是由操作系统所管理的。

Java中线程具有五种状态：

**初始化**

**可运行**

**运行中**

**阻塞**

**销毁**

这五种状态的转化关系如下：

![20190627111251312.png][]

JVM通过操作系统内核中的TCB（Thread Control Block）模块来改变线程的状态，这一过程需要耗费一定的CPU资源。

线程之间是如何进行协作的呢？

最经典的例子就是**生产者/消费者模式**

public class ProducerConsumerTest {
    
        public static void main(String args[]) {
            final Queue<Integer> sharedQueue = new LinkedList();
            Thread producer = new Producer(sharedQueue);
            Thread consumer = new Consumer(sharedQueue);
            producer.start();
            consumer.start();
        }
    }
    
    class Producer extends Thread {
    
        private static final int MAX_QUEUE_SIZE = 5;
        private final Queue sharedQueue;
        public Producer(Queue sharedQueue) {
        super();
        this.sharedQueue = sharedQueue;
    }
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
        synchronized (sharedQueue) {
        while (sharedQueue.size() >= MAX_QUEUE_SIZE) {
        System.out.println("队列满了，等待消费");
        try {
        sharedQueue.wait();
        } catch (InterruptedException e) {
        e.printStackTrace();
        }
        }
        sharedQueue.add(i);
        System.out.println("进行生产 : " + i);
        sharedQueue.notify();
        }
        }
    }
    }
    
    class Consumer extends Thread {private final Queue sharedQueue;
    
    public Consumer(Queue sharedQueue) {
        super();
        this.sharedQueue = sharedQueue;
    }
    @Override
    public void run() {
        while(true) {
        synchronized (sharedQueue) {
        while (sharedQueue.size() == 0) {
        try {
        System.out.println("队列空了，等待生产");
        sharedQueue.wait();
        } catch (InterruptedException e) {
        e.printStackTrace();
        }
        }
        int number = sharedQueue.poll();
        System.out.println("进行消费 : " + number );
        sharedQueue.notify();
        }
        }
    }
    }

上面的代码正确地实现了生产者/消费者模式，但是却并不是一个高性能的实现。为什么性能不高呢？原因如下：

1.涉及到同步锁。

2.涉及到线程阻塞状态和可运行状态之间的切换。

3.涉及到线程上下文的切换。

以上涉及到的任何一点，都是非常耗费性能的操作。

**协程：**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU5Mzk4NQ_size_16_color_FFFFFF_t_70 1][]

重要的是，**协程不是被操作系统内核所管理，而完全是由程序所控制**（也就是在用户态执行）。

这样带来的好处就是性能得到了很大的提升，不会像线程切换那样消耗资源。

既然协程这么好，它到底是怎么来使用的呢？

由于Java的原生语法中并没有实现协程（某些开源框架实现了协程，但是很少被使用），所以我们来看一看python当中对协程的实现案例，同样以生产者消费者模式为例：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU5Mzk4NQ_size_16_color_FFFFFF_t_70 2][]

代码中创建了一个叫做consumer的协程，并且在主线程中生产数据，协程中消费数据。

其中 **yield **是python当中的语法。当协程执行到yield关键字时，会暂停在那一行，等到主线程调用send方法发送了数据，协程才会接到数据继续执行。

但是，yield让协程暂停，和线程的阻塞是有本质区别的。协程的暂停完全由程序控制，线程的阻塞状态是由操作系统内核来进行切换。

因此，**协程的开销远远小于线程的开销。**

**协程的应用**

有哪些编程语言应用到了协程呢？我们举几个栗子：

**Lua语言**

Lua从5.0版本开始使用协程，通过扩展库coroutine来实现。

**Python语言**

正如刚才所写的代码示例，python可以通过 yield/send 的方式实现协程。在python 3.5以后，async/await 成为了更好的替代方案。

**Go语言**

Go语言对协程的实现非常强大而简洁，可以轻松创建成百上千个协程并发执行。

**Java语言**

如上文所说，Java语言并没有对协程的原生支持，但是某些开源框架模拟出了协程的功能，有兴趣的小伙伴可以看一看**Kilim框架**的源码：

https://github.com/kilim/kilim

以上参考 [http://www.sohu.com/a/237171690\_465221][http_www.sohu.com_a_237171690_465221] （**程序员小灰**）

[Link 1]: https://baike.baidu.com/item/%E5%87%BD%E6%95%B0%E8%B0%83%E7%94%A8/4127405
[https_www.liaoxuefeng.com_wiki_897692888725344_923057403198272]: https://www.liaoxuefeng.com/wiki/897692888725344/923057403198272
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU5Mzk4NQ_size_16_color_FFFFFF_t_70]: /images/20211223/82c1d5b01f9943f1b812fa49672dc820.png
[20190627111251312.png]: /images/20211223/2a25331d92604256a345b9ae861f8187.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU5Mzk4NQ_size_16_color_FFFFFF_t_70 1]: /images/20211223/056c9c7ce4ad497294f2a08ee81716fa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zOTU5Mzk4NQ_size_16_color_FFFFFF_t_70 2]: /images/20211223/89f43e0814f247269626a2d5dd0880c9.png
[http_www.sohu.com_a_237171690_465221]: http://www.sohu.com/a/237171690_465221