What is the difference between coroutines and threads in go language

Difference: 1. A thread can have multiple coroutines, and a process can also have multiple coroutines alone; 2. Threads are a synchronization mechanism, while coroutines are asynchronous; 3. Coroutines can retain The state at the time of a call, threads cannot; 4. Threads are preemptive, and coroutines are non-preemptive; 5. Threads are divided CPU resources, and coroutines are organized code processes, and coroutines need threads to host and run.

The operating environment of this tutorial: Windows 7 system, GO version 1.18, Dell G3 computer.

Thread

A thread refers to an execution unit within a process and is also a schedulable entity within the process. A thread is an entity of a process and the basic unit of CPU scheduling and dispatch. It is a basic unit that is smaller than a process and can run independently.

The thread itself basically does not own system resources. It only owns some resources that are essential during operation (such as a program counter, a set of registers and a stack), but it can be shared with other threads belonging to the same process. All resources owned by the process.

Inter-thread communication is mainly through shared memory, context switching is fast, and resource overhead is less, but compared with processes that are not stable enough, data is easily lost.

Coroutine

Coroutine is a lightweight thread in user mode, and the scheduling of coroutine is completely controlled by the user. From a technical perspective, "a coroutine is a function that you can pause execution of." Coroutines have their own register context and stack.

When the coroutine schedule is switched, the register context and stack are saved to other places. When switching back, the previously saved register context and stack are restored. Directly operating the stack basically has no overhead of kernel switching and does not need to be Locked access to global variables, so context switching is very fast.

The difference between coroutines and threads

A thread can have multiple coroutines, and a process can also have multiple coroutines alone.

Thread processes are all synchronous mechanisms, while coroutines are asynchronous.

The coroutine can retain the state of the last call. Each time the process re-enters, it is equivalent to entering the state of the last call.

Threads are preemptive, while coroutines are non-preemptive, so users need to release their usage rights to switch to other coroutines. Therefore, only one coroutine actually has the right to run at the same time, which is equivalent to a single thread. ability.

Coroutines do not replace threads, but are abstracted from threads. Threads are divided CPU resources, and coroutines are organized code processes. Coroutines need threads to host and run. Threads are the resources of coroutines, but coroutines do not directly use threads. Coroutines directly use executors ( Interceptor), the executor can be associated with any thread or thread pool, and can be the current thread, UI thread or create a new process.

Threads are resources of coroutines. Coroutines use the thread resource indirectly through Interceptor.

【Related recommendations: Go video tutorial, Programming teaching】

The above is the detailed content of What is the difference between coroutines and threads in go language. For more information, please follow other related articles on the PHP Chinese website!