Kotlin 的协程是真协程吗？被 b 站博主搞蒙了

协程简单理解就是用同步式的写法去写异步的代码，防止回调地狱。反编译 kotlin 到 java ，本质上还是一层回调嵌套一层回。因此，并不会比线程轻量级。至于你说的，能否实现 golang 的协程效果，完全是可以的，甚至就是为此而设计的。

coroutines 都差不多，算上 js 的，python 的，等等等等。似乎 C#的最早？但是不叫 coroutines

其实就是借助编译器，把函数拆成一个一个的 task ，然后用 event/message loop 来处理

Kotlin 协程在 Jvm 上的实现就是线程，其他平台上的实现不清楚。

stackfull coroutines

@zxjunz Java 能写回调吗？把局部变量的访问全部推到堆上？

不能，kt 协程里不能调用阻塞线程的方法，包括且不仅限于文件 IO ，网络 IO

@Kasumi20 #5 匿名内部类罢了，所有局部变量都会通过构造函数传到这个内部类里

go 的协程也会阻塞系统线程啊

只是 Go 的所有 IO 操作被封装过而已，不会直接调用系统 io

和 Kotlin 的效果是一样的，只是 kotlin 的想要不阻塞系统 thread ，需要调用特定 API 而已

协程就是用户态可重入的函数或过程，有的是手动重入比如生成器，有的是自动重入比如 async/await/绿色线程

协程的关键就是用户态的可重入，其他有栈无栈、自动重入手动重入都是基于此的概念

你应该先区分协程和异步ＩＯ的关系

@zxjunz kotlin 协程底层并不是回调嵌套，而是基于状态机的递归调用。

go 里面的 io 都是被包装过的，阻塞会自动调度走，kotlin 你用那些包装过的 io 也可以，不然会阻塞跑这个 coroutine 的线程，（ cgo 调用系统阻塞 io ，调度器就没辙了）

kotlin for jvm 的协程是包装的线程,非操作系统层级的协程

与协程（ coroutine ）相对的概念不是线程（ thread ）、进程（ process ），而是子例程（ subroutine ）
最夸张地说，使用 Kafka Celery 之类的工具作为唯一信道可以构造跨进程甚至跨机器的协程。
至于非阻塞 io ，只是和协程写法非常搭配罢了。但你也可以用 ponylang 那样的纯消息模式。

@zxjunz kotlin 语言层面定义了一次性续延（ one time continuation ），在那基础上构建的协程，我不认为编译到回调链能够正确地实现之，尤其是涉及控制结构（条件 / 循环）的时候。

@Kasumi20 我记得是很早就能写了（看到写 stream 的都写回调）。不过蕴含一个障碍，不能直接修改外层词法作用域的变量，必须使用容器类型，我认为这符合 #7 所说。

如果是系统调用应该还是会占用线程的

@unco020511 难道还有操作系统层级的协程？协程本来就是应用自己实现的

操作系统哪来的协成概念, 所有协程的概念都是语言提供的, go 是 runtime 层面直接提供, kotlin 则是一个统一的抽象, 在不同的 runtime 上提供不同的实现, 基本上都是翻译成状态机的实现

协程是协程，异步 IO 是异步 IO 。。

@fpure # 18 是吗,那可能是我理解错了吧

据我的了解，计算机领域协程没有统一的定义（要说统一可能就是线程再上层的抽象），不同语言中对协程的定义都不太一样，不像线程是依赖操作系统的。真协程……不太理解你说的

协程肯定是跑在线程上的，操作系统就没有协程的概念。
「非对称协程」大多数都是类似 Kotlin 这种实现，将一个函数体拆成多个 subroutine ，执行异步操作时，通过 continuation 保存上下文状态（包括代码行号、局部变量），并从当前函数退出；当异步操作完成时，会通过 continuation 重新进入该函数，并恢复上下文。

上面说错了，应该是「无栈协程」大多数都是类似 Kotlin 这种实现，将一个函数体拆成多个 subroutine ，执行异步操作时，通过 continuation 保存上下文状态（包括代码行号、局部变量），并从当前函数退出；当异步操作完成时，会通过 continuation 重新进入该函数，并恢复上下文。

Golang 那种是有栈协程。

其实就是回调,没那么难理解,举个例子:
doSth(xxx,new Listener(){
success(){}
})
success 就是写在回调里面的,这种方式一个是比较丑陋,第二个是会有回调地狱的问题,doSth 可以跑在主线程,success 可以跑在子线程里面,后面为了解决丑陋的问题,就有了 await 这个关键字,js 和 c#都有,语法就变成了这样:
await doSth()
success()
看到没有,如果有 await 他的语法是等价于上面那种东西的,doSth 可以跑在主线程,success 跑在了子线程里面,也就是用同步的方式写异步代码,线程发生了切换,但执行的顺序是同步的,本质上是回调
然后到了 kotlin,首先,kotlin 吹嘘协程是对开发产生了误导,他的本质其实就是类似 await,通过语法把回调屏蔽掉:
launch{
doSth()
success()
}
suspend doSth()
而 suspend 关键字就是类似于 await,async 的 async 一样,其实就是打个标记,告诉编译器,后面可以加回调,当线程执行 success 时,doSth 方法没有被执行,也就是所谓的挂起来了,而添加回调的方式叫做 continuation,也就是反编译后是类似这样的语法
doSth().continuation(success())
大概这样子

如果是通过回调的方式,除了 success 方法,还有一个 error 方法
doSth(xxx,new Listener(){
success(){}
error(){}
})
但是 kotlin 里面回调的语法是没有处理 error 的,所以它又搞了一堆异常机制,异常在协程里咋传播的,然后咋处理,设计的还挺复杂

“轻量”只是相对的概念，对于 CPU 密集的任务改用协程实现并不会有显著的性能提升，协程的主要目的是尽量避免无意义的等待 .