协程的概念

最新推荐文章于 2025-04-12 22:16:56 发布

一壶自由

最新推荐文章于 2025-04-12 22:16:56 发布

阅读量367

点赞数

本文深入探讨了协程的基本概念，对比线程和进程，强调了协程在提高执行效率和资源管理上的优势。协程由程序自身控制，避免了线程切换的开销，特别适合I/O密集型任务。文章还介绍了协程在Lua、Python和Go等语言中的实现，以及如何通过协程优化生产者/消费者模式。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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

概念：

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

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

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

特点：

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

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

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

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

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

参考：https://www.liaoxuefeng.com/wiki/897692888725344/923057403198272

再次区别一下进程和线程

进程是什么呢？

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

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

线程又是什么呢？

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

线程拥有自己的栈空间。

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

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

Java中线程具有五种状态：

初始化

可运行

运行中

阻塞

销毁

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

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.涉及到线程上下文的切换。

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

协程：