According to Wikipedia, coroutines are based on cooperative multitasking, which makes them less resource-hungry than threads. No context switch, no blocking, no expensive system calls, no critical sections and so on.

In other words, all those coroutine benefits seem to come from disallowing multithreading in the first place. This makes coroutines single-threaded by nature: concurrency is achieved, but no true parallelism.

Is it true? Is it possible to implement coroutines by using multiple threads instead?

CodePudding user response：

Coroutines allow multitasking without multithreading, but they don't disallow multithreading.

In languages that support both, a coroutine that is put to sleep can be re-awakened in a different thread.

The usual arrangement for CPU-bound tasks is to have a thread pool with about twice as many threads as you have CPU cores. This thread pool is then used to execute maybe thousands of coroutines simultaneously. The threads share a queue of coroutines ready to execute, and whenever a thread's current coroutine blocks, it just gets another one to work on from the queue.

In this situation you have enough busy threads to keep your CPU busy, and you still have thread context switches, but not enough of them to waste significant resources. The number of coroutine context switches is thousands of times higher.

CodePudding user response：

Multiple coroutines can be mapped to a single OS thread. But a single OS thread can only utilize 1 CPU. So you need multiple OS threads to utilize multiple CPUs.

So if a coroutine scheduler needs to utilize multiple CPUs (very likely), it needs to make use of multiple OS threads.

Have a look at the Go scheduler and look for MN scheduler.