来自Python Coroutine:

Python协程的执行可以在许多地方暂停和恢复 点(见协程)。在协程函数体内，等待 异步标识符成为保留关键字;等待表达式, Async for和Async with只能在协程函数中使用 的身体。

From Coroutines (c++ 20)

协程是一种可以挂起要恢复的执行的函数 以后。协程是无堆栈的:它们通过返回来暂停执行 给打电话的人。这允许执行顺序代码 异步(例如，不显式地处理非阻塞I/O 回调)，并且还支持惰性计算无限上的算法 序列和其他用途。

与他人的答案比较:

在我看来，后面的恢复部分是一个核心的区别，就像@Twinkle一样。 虽然文件的很多方面还在完善中，但是这一部分和大部分的答案是相似的，除了@南晓

另一方面，协程是协作的:在任何给定的时间，一个 带有协程的程序只运行其中一个协程，并且 这个正在运行的协程仅在显式执行时才会暂停执行 请求被暂停。

因为引用自Program in Lua，可能是语言相关(目前不熟悉Lua)，不是所有文档都只提到一个部分。

与concurrent的关系: 协程(c++ 20)中有一个“执行”部分。太长了，不能在这里引用。 除了细节，还有几个状态。

When a coroutine begins execution  
When a coroutine reaches a suspension point  
When a coroutine reaches the co_return statement  
If the coroutine ends with an uncaught exception  
When the coroutine state is destroyed either because it terminated via co_return or uncaught exception, or because it was destroyed via its handle 

正如@Adam Arold在@user217714的回答下的评论。并发性。 但它与多线程不同。 从std::线程

Threads allow multiple functions to execute concurrently. Threads begin execution immediately upon construction of the associated thread object (pending any OS scheduling delays), starting at the top-level function provided as a constructor argument. The return value of the top-level function is ignored and if it terminates by throwing an exception, std::terminate is called. The top-level function may communicate its return value or an exception to the caller via std::promise or by modifying shared variables (which may require synchronization, see std::mutex and std::atomic)

因为它是并发的，它就像多线程一样工作，特别是当等待是不可避免的(从操作系统的角度来看)，这也是为什么它令人困惑的原因。

我将详述@user21714的答案。协程是独立的执行路径，不能同时运行。它们依赖于一个控制器(例如python控制器库)来处理这些路径之间的切换。但是为了实现这一点，协同程序本身需要调用yield或类似的结构，以允许它们的执行暂停。

相反，线程运行在独立的计算资源上，并且彼此并行。由于它们位于不同的资源上，因此不需要调用yield来允许其他执行路径继续进行。

您可以通过启动一个多线程程序(例如jvm应用程序)来看到这种效果，其中所有八个核心i7超线程核心都被利用了:您可能会在Activity Monitor或Top中看到797%的利用率。相反，当运行一个典型的python程序(即使是带有协程或python线程的程序)时，利用率最高将达到100%。例如，一台机器超线程。

协程和并发在很大程度上是正交的。协程是一种通用的控制结构，流控制在两个不同的例程之间协作传递而不返回。

Python中的'yield'语句就是一个很好的例子。它创建了一个协程。当遇到yield时，将保存函数的当前状态，并将控制返回给调用函数。然后，调用函数可以将执行转移回屈服函数，它的状态将恢复到遇到“屈服”的位置，并继续执行。

来自Python Coroutine:

Python协程的执行可以在许多地方暂停和恢复 点(见协程)。在协程函数体内，等待 异步标识符成为保留关键字;等待表达式, Async for和Async with只能在协程函数中使用 的身体。

From Coroutines (c++ 20)

协程是一种可以挂起要恢复的执行的函数 以后。协程是无堆栈的:它们通过返回来暂停执行 给打电话的人。这允许执行顺序代码 异步(例如，不显式地处理非阻塞I/O 回调)，并且还支持惰性计算无限上的算法 序列和其他用途。

与他人的答案比较:

在我看来，后面的恢复部分是一个核心的区别，就像@Twinkle一样。 虽然文件的很多方面还在完善中，但是这一部分和大部分的答案是相似的，除了@南晓

另一方面，协程是协作的:在任何给定的时间，一个 带有协程的程序只运行其中一个协程，并且 这个正在运行的协程仅在显式执行时才会暂停执行 请求被暂停。

因为引用自Program in Lua，可能是语言相关(目前不熟悉Lua)，不是所有文档都只提到一个部分。

与concurrent的关系: 协程(c++ 20)中有一个“执行”部分。太长了，不能在这里引用。 除了细节，还有几个状态。

When a coroutine begins execution  
When a coroutine reaches a suspension point  
When a coroutine reaches the co_return statement  
If the coroutine ends with an uncaught exception  
When the coroutine state is destroyed either because it terminated via co_return or uncaught exception, or because it was destroyed via its handle 

正如@Adam Arold在@user217714的回答下的评论。并发性。 但它与多线程不同。 从std::线程

Threads allow multiple functions to execute concurrently. Threads begin execution immediately upon construction of the associated thread object (pending any OS scheduling delays), starting at the top-level function provided as a constructor argument. The return value of the top-level function is ignored and if it terminates by throwing an exception, std::terminate is called. The top-level function may communicate its return value or an exception to the caller via std::promise or by modifying shared variables (which may require synchronization, see std::mutex and std::atomic)

因为它是并发的，它就像多线程一样工作，特别是当等待是不可避免的(从操作系统的角度来看)，这也是为什么它令人困惑的原因。

在Lua编程中，“协程”部分:

A coroutine is similar to a thread (in the sense of multithreading): it is a line of execution, with its own stack, its own local variables, and its own instruction pointer; but it shares global variables and mostly anything else with other coroutines. The main difference between threads and coroutines is that, conceptually (or literally, in a multiprocessor machine), a program with threads runs several threads in parallel. Coroutines, on the other hand, are collaborative: at any given time, a program with coroutines is running only one of its coroutines, and this running coroutine suspends its execution only when it explicitly requests to be suspended.

所以关键是:协程是“协作的”。即使在多核系统中，也只有一个协程在任何给定时间运行(但多个线程可以并行运行)。协程之间存在不可抢占性，运行中的协程必须显式放弃执行。

关于“并发性”，你可以参考Rob Pike的幻灯片:

并发是独立执行计算的组合。

所以在协程A的执行过程中，它把控制权传递给了协程B。经过一段时间后，协程B又把控制权传递给了协程A。由于协程之间存在依赖关系，它们必须串联运行，所以这两个协程不是并发的。

协程是Kotlin语言中可用的很棒的特性 协程是一种新的异步、非阻塞的编写方式 代码(以及更多) 协程是轻量级线程。一根轻的线就意味着它 不映射到本机线程，因此不需要上下文切换 在处理器上，所以它们更快。 它不映射到本机线程上 协程和线程都是多任务处理。但是区别在于 线程由操作系统管理，协程由用户管理。

基本上，有两种类型的协程:

Stackless Stackful

Kotlin实现了无堆栈协程-这意味着 协程没有自己的堆栈，所以它们不会映射到本机线程上。

这些是启动协程的函数:

launch{}

async{}

你可以在这里了解更多:

https://www.kotlindevelopment.com/deep-dive-coroutines/

https://blog.mindorks.com/what-are-coroutines-in-kotlin-bf4fecd476e9