运维锅总详解进程、内核线程、用户态线程和协程

I/O 密集型应用、计算密集型应用应该用什么实现？进程、内核线程、用户态线程、协程它们的原理和应用场景又是什么？如何组合它们才能让机器性能达到最优？它们的死锁和竞态又是什么？如何清晰地表示它们之间的关系？希望读完本文后，能帮您解答这些疑惑！

一、进程、内核线程、用户态线程和协程的介绍

1. 进程

实现原理

内存空间：进程有自己独立的地址空间，彼此之间内存隔离。
调度：由操作系统内核负责调度。每个进程有自己的资源和状态，如文件描述符、栈、数据段等。
通信：进程间通信（IPC）比较复杂，需要使用操作系统提供的机制，如管道、消息队列、共享内存、信号等。

应用场景

安全性和稳定性要求高：由于进程之间相互隔离，一个进程的崩溃不会影响其他进程。
多任务处理：可以同时运行多个程序，如浏览器、文本编辑器等。
分布式系统：例如微服务架构，每个服务可以作为一个独立的进程运行。

2. 内核线程

实现原理

内存空间：内核线程共享同一进程的地址空间，可以访问同一组资源（如文件描述符）。
调度：由操作系统内核负责调度。线程有独立的栈和寄存器上下文，但共享进程的全局内存和资源。
通信：线程之间通信简单，因共享同一地址空间，可以直接读写共享内存。

应用场景

并行计算：利用多核 CPU 提高计算密集型任务的性能。
高并发服务器：如 Web 服务器，可以使用多线程处理并发请求。
实时系统：需要快速响应的系统，如实时数据处理、游戏引擎等。

3. 用户态线程

实现原理

内存空间：用户态线程共享同一进程的地址空间，所有线程在用户空间中调度，不涉及内核态切换。
调度：由用户空间的线程库（如 Pthreads）负责调度，切换开销小，不涉及内核态切换。
通信：线程之间通信简单，因共享同一地址空间，可以直接读写共享内存。

应用场景

需要高效上下文切换的场景：如轻量级的任务调度。
嵌入式系统：资源受限的系统中使用用户态线程可以减少系统开销。
应用程序模拟：模拟操作系统的多线程环境，进行实验和教学。

4. 协程

实现原理

内存空间：协程在同一个线程内执行，切换时只需要保存和恢复少量的寄存器和栈信息。
调度：协程采用协作式调度，即由程序显式控制何时切换协程，通常使用 yield、await 等语法。
通信：由于协程在同一线程内执行，通信非常简单，可以直接共享数据或通过轻量级的同步机制。

应用场景

高并发 I/O 密集型应用：如 Web 服务器、数据库服务器，通过异步 I/O 和协程结合，提高并发处理能力。
异步编程：如网络编程、GUI 编程，通过协程实现异步操作，避免回调地狱。
任务调度：如游戏开发中的逻辑更新、协作式多任务系统。

具体示例

进程

场景：运行两个独立的程序。

import os

def child():
    print(f"Child process {os.getpid()}")

def parent():
    print(f"Parent process {os.getpid()}")
    if os.fork() == 0:
        child()
    else:
        os.wait()

parent()

内核线程

场景：并行计算任务。

#include <stdio.h>
#include <pthread.h>

#define NUM_THREADS 4

void* compute(void* arg) {
    // 执行计算密集型任务
    for (long i = 0; i < 1000000000; i++) {
        // 一些计算操作
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, compute, NULL);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    return 0;
}

用户态线程

场景：轻量级任务调度。

#include <stdio.h>
#include <ucontext.h>

#define STACK_SIZE 1024*64
#define NUM_THREADS 4

ucontext_t contexts[NUM_THREADS];
char stacks[NUM_THREADS][STACK_SIZE];
int current = 0;

void thread_func(int id) {
    for (int i = 0; i < 5; i++) {
        printf("Thread %d: %d\n", id, i);
        swapcontext(&contexts[id], &contexts[(id + 1) % NUM_THREADS]);
    }
}

int main() {
    for (int i = 0; i < NUM_THREADS; i++) {
        getcontext(&contexts[i]);
        contexts[i].uc_stack.ss_sp = stacks[i];
        contexts[i].uc_stack.ss_size = STACK_SIZE;
        contexts[i].uc_link = &contexts[(i + 1) % NUM_THREADS];
        makecontext(&contexts[i], (void(*)(void))thread_func, 1, i);
    }
    setcontext(&contexts[0]);
    return 0;
}

协程

场景：异步 I/O 操作。

package main

import (
    "fmt"
    "time"
)

func asyncTask(id int, done chan bool) {
    time.Sleep(2 * time.Second)
    fmt.Printf("Task %d done\n", id)
    done <- true
}

func main() {
    done := make(chan bool, 3)
    for i := 1; i <= 3; i++ {
        go asyncTask(i, done)
    }
    for i := 1; i <= 3; i++ {
        <-done
    }
}

总结

进程：适用于安全性和稳定性要求高的多任务处理和分布式系统。
内核线程：适用于并行计算、高并发服务器和实时系统，能够充分利用多核 CPU。
用户态线程：适用于需要高效上下文切换的轻量级任务调度和资源受限的嵌入式系统。
协程：适用于高并发 I/O 密集型应用、异步编程和任务调度，通过协作式调度实现高效的并发处理。

这些并发模型各有特点和适用场景，选择适当的模型可以显著提高应用程序的性能和效率。

二、I/O 密集型应用为什么更适合用协程实现？

协程的异步编程模型在 I/O 密集型应用中表现出色，这主要是因为 I/O 密集型程序的特性和资源需求与协程的优势高度契合。以下是对 I/O 密集型程序的资源需求及其与协程异步编程模型匹配的详细解释：

I/O 密集型程序的特性和资源需求

等待时间长：
- 特点：I/O 密集型程序通常会在等待磁盘读写、网络通信或其他外部设备的响应，这些操作可能会阻塞当前线程或进程，导致 CPU 资源闲置。
- 资源需求：需要一种高效的方式来处理长时间的 I/O 等待，以便充分利用 CPU 资源。
高并发连接：
- 特点：I/O 密集型应用（如 Web 服务器、数据库服务器）通常需要处理大量的并发连接，每个连接可能需要独立的处理逻辑。
- 资源需求：需要能够高效管理大量并发连接，并在每个连接上执行 I/O 操作而不阻塞其他连接。
低延迟响应：
- 特点：对于用户交互频繁的 I/O 密集型应用（如聊天服务器、实时数据处理系统），低延迟响应非常重要。
- 资源需求：需要一种方法来快速处理 I/O 操作并立即响应用户请求，保持系统的高响应速度。

协程的优势

轻量级上下文切换：
- 特点：协程的上下文切换开销极小，因为不涉及进入内核态。上下文切换只需保存和恢复少量寄存器和栈信息。
- 匹配：在处理 I/O 操作时，协程可以快速切换到其他任务，而不浪费 CPU 资源等待 I/O 完成。
协作式调度：
- 特点：协程采用协作式调度，切换由程序显式控制（如通过 yield 或等待 I/O 操作），不会在不合适的时刻被抢占。
- 匹配：这种调度方式减少了不必要的上下文切换，并使程序能够在合适的时机切换到其他协程，从而提高了系统的整体效率。
高效的异步编程：
- 特点：协程可以与异步 I/O 结合，实现非阻塞 I/O 操作。在等待 I/O 完成时，协程可以执行其他任务。
- 匹配：这种异步编程模型非常适合处理大量并发 I/O 请求，避免了阻塞等待，从而提高了系统的吞吐量和响应速度。

实际示例

使用协程的异步编程模型处理 I/O 密集型任务

场景：高并发 Web 服务器

在这种场景中，服务器需要处理大量并发的 HTTP 请求，每个请求可能涉及 I/O 操作（如读取文件或访问数据库）。使用协程可以有效管理这些并发请求，并在等待 I/O 时继续处理其他请求。

package main

import (
    "fmt"
    "net/http"
    "time"
)

// 模拟 I/O 操作
func simulateIO() {
    time.Sleep(2 * time.Second) // 模拟耗时 I/O 操作
}

func handler(w http.ResponseWriter, r *http.Request) {
    simulateIO() // 执行 I/O 操作
    fmt.Fprintf(w, "Hello, World!")
}

func main() {
    http.HandleFunc("/", handler)
    http.ListenAndServe(":8080", nil)
}

在这个例子中，使用 Go 的 Goroutine 实现了一个高并发 Web 服务器，每个请求由一个 Goroutine 处理。在处理 I/O 操作时，Goroutine 可以切换到其他请求，从而充分利用 CPU 资源，提高服务器的并发处理能力。

总结

I/O 密集型程序：通常涉及大量的等待时间和高并发连接，需要高效管理等待状态并保持低延迟响应。
协程的优势：轻量级上下文切换、协作式调度、高效的异步编程模型，使得协程能够在 I/O 密集型应用中高效处理大量并发请求，减少资源浪费，提高系统响应速度和吞吐量。

协程的异步编程模型正是通过这些优势，完美契合了 I/O 密集型程序的需求，从而在这类应用中表现出色。

三、计算密集型应用为什么更适合用内核线程实现？

对于计算密集型任务，选择适当的并发模型可以显著影响性能。计算密集型任务主要是指那些主要消耗 CPU 资源而不是 I/O 资源的任务，如科学计算、数据处理、图像处理等。在这种情况下，内核线程、用户态线程和协程各有优缺点，下面是详细的分析。

1. 内核线程

特性

并行性：内核线程可以充分利用多核 CPU 的优势，每个线程可以在不同的核心上并行执行。
调度：由操作系统内核负责调度，能够自动处理线程的优先级、负载均衡等问题。
资源消耗：每个线程都有独立的栈和寄存器，需要较大的内存开销。创建和切换线程的开销较大，因为涉及到内核态的上下文切换。

适用性

计算密集型任务：内核线程适合计算密集型任务，因为它能够在多核处理器上并行执行，从而加速计算过程。通过合理的线程数目，可以充分利用所有可用的 CPU 核心。

示例

#include <stdio.h>
#include <pthread.h>

#define NUM_THREADS 4

void* compute(void* arg) {
    // 执行计算密集型任务
    for (long i = 0; i < 1000000000; i++) {
        // 一些计算操作
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, compute, NULL);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    return 0;
}

2. 用户态线程

特性

并行性：在多核 CPU 上，用户态线程可以利用内核线程，但用户态线程自身不提供真正的并行能力。所有用户态线程仍然由一个内核线程调度。
调度：调度由用户空间的线程库管理，调度开销较小。
资源消耗：相对较少的内存开销，但无法利用多核 CPU 的全部能力，因为所有用户态线程共享一个内核线程。

适用性

计算密集型任务：用户态线程不如内核线程那样直接利用多核 CPU 的优势，因此在计算密集型任务中，用户态线程通常不如内核线程有效。不过，它们在内核线程存在的情况下可以提供较轻量级的并发控制。

示例

#include <stdio.h>
#include <pthread.h>

#define NUM_THREADS 4

void* compute(void* arg) {
    // 执行计算密集型任务
    for (long i = 0; i < 1000000000; i++) {
        // 一些计算操作
    }
    return NULL;
}

int main() {
    pthread_t threads[NUM_THREADS];
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_create(&threads[i], NULL, compute, NULL);
    }
    for (int i = 0; i < NUM_THREADS; i++) {
        pthread_join(threads[i], NULL);
    }
    return 0;
}

3. 协程

特性

并行性：协程的调度是由程序控制的，通常在单个内核线程中执行。它们不能直接利用多核 CPU 的能力，但可以高效地管理大量并发任务。
调度：协程的上下文切换开销极小，因为不涉及内核态的上下文切换。协程切换由程序控制，通常较为高效。
资源消耗：协程的内存开销非常小，因为协程的栈较小，切换开销低。

适用性

计算密集型任务：由于协程通常在单个线程中执行，不适合充分利用多核 CPU 的优势，因此在计算密集型任务中不如内核线程高效。它们更适合 I/O 密集型任务和需要处理大量并发的场景。

示例

协程通常在编程语言中有特定的实现，如 Python 的 asyncio，Go 的 Goroutines。以下是一个 Go 协程的示例，展示了如何使用协程来处理任务：

package main

import (
    "fmt"
    "sync"
)

const numRoutines = 4

func compute(id int, wg *sync.WaitGroup) {
    defer wg.Done()
    for i := 0; i < 1000000000; i++ {
        // 一些计算操作
    }
    fmt.Printf("Routine %d finished\n", id)
}

func main() {
    var wg sync.WaitGroup
    for i := 0; i < numRoutines; i++ {
        wg.Add(1)
        go compute(i, &wg)
    }
    wg.Wait()
}

总结

计算密集型任务：内核线程更合适，因为它们能够直接利用多核 CPU 的能力进行并行计算。内核线程的调度由操作系统管理，可以有效地分配计算负载。
用户态线程：在内核线程的支持下可以提供轻量级的并发，但通常无法像内核线程那样充分利用多核 CPU。
协程：虽然协程提供了轻量级的上下文切换和高效的异步编程模型，但由于它们在单个线程中执行，无法直接利用多核 CPU 的并行计算能力。因此，它们不适合计算密集型任务，适合 I/O 密集型任务和高并发场景。

四、进程、内核线程、用户态线程、协程如何组合？

进程、内核线程、用户态线程和协程各自有不同的特性和应用场景。通过合理组合这些技术，可以优化各种不同类型的应用场景。以下是一些常见的组合策略及其适用场景：

1. 进程、内核线程、用户态线程的组合

1.1. 进程 + 内核线程

适用场景：

高并发和隔离性要求：例如，大型分布式服务、数据库系统等，需要在隔离的内存空间中运行多个任务，并充分利用多核 CPU。

组合方式：

进程用于隔离不同的服务模块或任务，确保不同任务之间的内存隔离和可靠性。
内核线程在每个进程内运行，利用多核 CPU 实现真正的并行处理。

示例：

Web 服务器：如 Nginx 使用多进程模型来处理客户端请求，每个进程可以使用多个内核线程来处理并发连接。

1.2. 进程 + 用户态线程

适用场景：

轻量级并发任务和资源受限环境：如某些轻量级的应用程序需要并发处理，但对多核处理需求不高。

组合方式：

进程用于提供独立的内存空间和隔离。
用户态线程在单个进程内提供并发处理能力，减少线程创建和上下文切换的开销。

示例：

轻量级的网络服务：如使用用户态线程的网络服务器来处理大量并发连接，但不需要高强度的并行计算。

2. 内核线程、用户态线程和协程的组合

2.1. 内核线程 + 协程

适用场景：

高并发和计算密集型任务：需要利用多核 CPU 进行并行计算，同时处理大量并发操作。

组合方式：

内核线程用于实现多核并行处理，处理计算密集型任务。
协程在每个内核线程内进行调度，处理大量的异步 I/O 操作或轻量级任务。

示例：

高并发的数据处理应用：如某些数据分析系统，其中内核线程处理计算密集型任务，而协程处理并发的 I/O 操作。

2.2. 用户态线程 + 协程

适用场景：

高并发且不需要多核并行的任务：如处理大量并发 I/O 请求的应用，但对计算密集型任务需求较低。

组合方式：

用户态线程提供基础的并发处理能力和较低的上下文切换开销。
协程在用户态线程中进行调度，提高异步操作的效率。

示例：

网络爬虫：用户态线程处理爬虫任务的并发请求，而协程处理每个请求的异步 I/O 操作。

3. 进程、内核线程、协程的组合

3.1. 进程 + 内核线程 + 协程

适用场景：

复杂的高性能应用：需要高隔离性、高并发处理和高计算性能的应用。

组合方式：

进程用于任务的隔离和容错，确保每个服务模块独立。
内核线程在每个进程中实现多核并行处理。
协程在每个内核线程中进行高效的异步操作和轻量级任务处理。

示例：

大型分布式系统：如分布式数据库系统，利用进程隔离不同服务，内核线程进行并行计算，协程处理高并发的 I/O 操作。

总结

进程提供内存隔离和稳定性，适用于需要高隔离性和独立性的任务。结合内核线程和协程可以实现高并发和多核处理。
内核线程用于实现真正的多核并行处理，适合计算密集型任务。可以与进程和协程结合，以优化并行计算和异步处理。
用户态线程适合轻量级并发任务，通常与进程结合使用。结合协程可以进一步提高并发处理能力。
协程适合处理大量并发的异步操作，通常与内核线程结合使用，以实现高效的并发和异步处理。

选择适当的组合方式可以根据应用的并发需求、计算需求、资源限制和系统要求来优化性能和效率。

五、死锁和竞态简介

死锁和竞态条件是多线程编程中常见的并发问题。它们都涉及线程或进程在访问共享资源时的相互作用，但它们的根本原因和表现形式不同。以下是这两个问题的详细解释：

死锁（Deadlock）

定义：
死锁是指两个或多个线程在运行过程中因争夺资源而形成一种互相等待的状态，导致它们都无法继续执行。

发生条件：

互斥条件：至少有一个资源必须处于非共享模式，即只有一个线程可以使用该资源。
持有并等待条件：一个线程持有一个资源，同时请求其他资源。
非抢占条件：已经分配给线程的资源不能被抢占，即资源不能被强制从线程中回收。
循环等待条件：存在一个线程等待的资源形成一个循环等待链，其中每个线程都在等待下一个线程持有的资源。

示例：
假设有两个线程（A 和 B），两个资源（R1 和 R2）。线程 A 已经持有 R1 并请求 R2，线程 B 已经持有 R2 并请求 R1。此时，线程 A 和线程 B 都在等待对方释放资源，导致死锁。

解决方法：

避免死锁：通过设计避免死锁发生，如资源分配的顺序和策略。
检测和恢复：定期检查系统中是否存在死锁，并采取措施恢复。
预防死锁：通过预防技术（如限制资源的请求顺序）来确保死锁不会发生。

竞态条件（Race Condition）

定义：
竞态条件是指多个线程或进程在执行并发操作时，由于操作顺序的不同导致程序的行为无法预测或产生错误结果。

发生原因：
竞态条件发生在多个线程或进程同时访问共享资源且至少有一个线程或进程进行写操作，而操作的结果取决于访问的顺序。

示例：
假设有两个线程同时对一个共享变量 counter 进行递增操作。线程 1 和线程 2 都读取 counter 的值，递增它，然后写回。如果没有适当的同步机制，两个线程可能会读取到相同的值并写回相同的结果，导致丢失更新。

解决方法：

互斥锁：使用互斥锁（mutex）来确保同一时间只有一个线程可以访问共享资源。
原子操作：使用原子操作（atomic operations）来保证对共享变量的读写操作是不可分割的。
条件变量：使用条件变量来协调线程间的执行顺序，确保在访问共享资源时的正确顺序。

对比

死锁是一种特定的阻塞状态，所有涉及的线程都处于等待状态，无法继续执行。
竞态条件 是一种错误状态，由于并发操作的顺序不同导致程序产生不一致的结果或错误。

总结

死锁和 竞态条件 都是多线程编程中需要特别注意的问题，但它们的原因和影响不同。死锁涉及到线程间的资源竞争和等待状态，而竞态条件涉及到线程间的操作顺序和共享资源的正确性。
避免死锁 通常需要设计和协议的改变，解决竞态条件 则需要通过同步机制和原子操作来确保线程安全。

六、进程、内核线程、用户线程、协程中的死锁和竞态

在进程、内核线程、用户线程和协程的环境中，死锁和竞态条件都是可能出现的问题，但它们的表现形式和解决方法会有所不同。以下是每种环境中死锁和竞态条件的详细说明：

1. 进程

死锁

可能性：在多进程程序中，死锁是可能的。尤其是在使用进程间通信（IPC）和共享资源时，多个进程可能会因争夺资源而陷入死锁。
原因：进程间的资源争用、互相等待等情况可能导致死锁。
解决方法：避免死锁的策略包括：避免循环等待、请求资源的顺序等。还可以通过使用超时机制和死锁检测算法来解决。

竞态条件

可能性：在多进程环境中，竞态条件也是可能的。多个进程同时访问共享资源而没有适当的同步措施时，可能会出现竞态条件。
原因：竞态条件发生在多个进程并发访问和修改共享资源时。
解决方法：使用进程间同步机制（如信号量、互斥锁、共享内存等）来保护共享资源，确保操作的原子性。

2. 内核线程

死锁

可能性：内核线程中同样可能出现死锁，尤其是在多线程程序中涉及多个资源的分配时。
原因：内核线程可能会因为锁的争用和资源的循环等待导致死锁。
解决方法：使用适当的锁策略、避免循环等待、使用死锁检测和恢复机制等。

竞态条件

可能性：内核线程中也可能出现竞态条件，尤其是当多个线程并发访问共享资源时。
原因：竞态条件发生在多个内核线程并发访问和修改共享资源时。
解决方法：使用内核提供的同步原语（如互斥锁、条件变量、信号量等）来保护共享资源。

3. 用户线程

死锁

可能性：用户线程中也可能出现死锁，特别是在多线程程序中处理共享资源时。
原因：用户线程通过用户空间的线程库进行调度，多个线程可能因锁的争用和资源的循环等待而陷入死锁。
解决方法：使用适当的线程同步机制，避免锁的循环等待和死锁的形成。

竞态条件

可能性：用户线程中出现竞态条件的可能性较高，尤其是在缺乏适当同步的情况下。
原因：竞态条件发生在多个用户线程并发访问和修改共享数据时。
解决方法：使用线程同步原语（如互斥锁、条件变量、读写锁等）来确保线程安全和数据一致性。

4. 协程

死锁

可能性：在使用协程时，通常不会出现传统意义上的死锁，因为协程通常在单线程环境下调度，不会有多个线程争夺资源的问题。
原因：协程是由用户程序控制调度的，不涉及线程间的资源竞争。
解决方法：确保协程之间的协作逻辑正确，避免设计上的死锁情况，如不适当的协程等待。

竞态条件

可能性：在协程中也可能出现竞态条件，尤其是在多个协程同时操作共享资源时。
原因：尽管协程在单线程中运行，但多个协程之间仍然需要正确的同步来避免竞态条件。
解决方法：使用适当的同步机制，如协程库提供的同步原语（例如事件、信号量、条件变量等）来管理协程之间的协作。

总结

进程、内核线程、用户线程和协程都可能面临死锁和竞态条件，但它们的表现和解决方法有所不同。
进程和内核线程在多进程和多线程的环境中，因资源竞争和同步问题容易出现这些问题。
用户线程和协程通常在用户空间中进行调度，也会遇到这些问题，但协程的单线程模型减少了传统死锁的可能性。
解决这些问题的方法包括使用适当的同步机制、设计避免死锁的资源分配策略、以及确保操作的原子性。

七、进程、内核线程、用户态线程和协程之间的关系

下面是更详细的 Mermaid 图，展示了进程、内核线程、用户态线程和协程之间的关系，以及它们如何与内存、CPU 和磁盘进行交互：

图的详细说明

系统资源 (System Resources):
- CPU: 执行计算任务的核心处理单元。
- Memory: 存储程序代码、数据和运行时状态的资源。
- Disk: 存储持久化数据和程序的硬盘。
进程 (Processes):
- Process 1 (P1): 一个独立的执行环境，包含独立的内存空间。
- Process 2 (P2): 另一个独立的执行环境。
- Process 3 (P3): 另一个独立的执行环境。
进程到内核线程：
- 进程可以创建并使用多个内核线程进行并行计算。
进程到内存：
- 进程使用内存来存储其代码、数据和状态。
进程到磁盘：
- 进程进行磁盘读写操作，存储持久数据。
内核线程 (Kernel Threads):
- Kernel Thread 1 (KT1): 内核级线程，能够在 CPU 上执行。
- Kernel Thread 2 (KT2): 另一个内核级线程。
内核线程到 CPU:
- 内核线程在 CPU 上执行任务。
内核线程到内存:
- 内核线程使用内存来执行任务。
用户态线程 (User Threads):
- User Thread 1 (UT1): 用户空间中的线程，运行在内核线程上。
- User Thread 2 (UT2): 另一个用户线程。
用户线程到内核线程:
- 用户线程运行在内核线程上，通过内核线程获得 CPU 时间。
用户线程到内存:
- 用户线程使用内存来存储其局部变量和状态。
协程 (Coroutines):
- Coroutine 1 (C1): 用户态的轻量级线程，用于异步处理。
- Coroutine 2 (C2): 另一个协程。
协程到用户线程:
- 协程运行在用户线程内，由用户线程调度。
协程到内存:
- 协程使用内存来存储其状态和局部数据。