返回专栏
· 23 分钟阅读

同步与异步


一、同步与异步的基本概念

同步(Synchronous)和异步(Asynchronous)描述的是任务之间如何协调执行,以及调用方是否需要等待操作完成。

1. 同步(Synchronous)

同步是一种调用与结果获取之间具有直接等待关系的执行方式。

调用方发起操作后,需要等待操作完成,才能继续执行依赖该结果的后续逻辑。

典型特征:

  • 调用顺序具有明确的先后关系。
  • 调用方通常需要等待结果。
  • 后续逻辑依赖当前操作的完成。
  • 执行流程容易理解和调试。
  • 如果等待期间无法执行其他工作,可能造成线程资源浪费。

示例:

import time

def fetch_data():
    time.sleep(2)
    return {"name": "Alice"}

result = fetch_data()

print(result)
print("继续执行")

执行 fetch_data() 时,当前线程等待约两秒,函数返回后才继续执行后续语句。

2. 异步(Asynchronous)

异步是一种将操作发起与操作完成解耦的执行方式。

调用方发起操作后,不必一直等待操作完成,可以继续执行其他任务。操作完成后,再通过回调、事件、Future、Promise 或其他机制获取结果。

典型特征:

  • 操作发起和操作完成可以分离。
  • 调用方不必持续阻塞等待。
  • 任务完成后通过通知或结果对象进行协作。
  • 适合处理大量 I/O 等待任务。
  • 需要管理任务状态、异常和结果传播。

示例:

function fetchData() {
    return new Promise((resolve) => {
        setTimeout(() => {
            resolve({ name: "Alice" });
        }, 2000);
    });
}

async function main() {
    const result = await fetchData();
    console.log(result);
}

main();
console.log("主流程继续执行");

fetchData() 返回 Promise 后,调用方可以先执行其他逻辑。await 会暂停当前异步函数后续部分的执行,但通常不会阻塞 JavaScript 事件循环线程。

3. 同步与异步的核心区别

比较维度 同步 异步
调用关系 调用与结果获取紧密关联 调用与结果获取可以分离
等待方式 通常等待操作完成 可以先执行其他任务
执行流程 顺序式流程 事件或任务驱动
结果获取 直接返回或等待返回 回调、Future、Promise 等
线程占用 可能阻塞当前线程 可避免等待期间占用执行线程
编程复杂度 通常较低 状态和错误处理更复杂
适用场景 简单流程、计算任务 I/O 密集、高并发任务

需要注意:同步不等于单线程,异步也不等于多线程。同步和异步描述的是协作与等待语义,而单线程、多线程描述的是执行资源和执行实体。


二、同步与异步的执行机制

1. 同步调用机制

同步调用通常采用直接调用和返回值传递的方式。

调用方进入函数后,当前调用链需要等待函数返回。

sequenceDiagram
    participant A as 调用方
    participant B as 被调用方

    A->>B: 发起操作
    Note over A: 等待结果
    B->>B: 执行操作
    B-->>A: 返回结果
    A->>A: 继续执行

执行过程:

  1. 调用方发起请求。
  2. 被调用方开始处理。
  3. 调用方等待处理结果。
  4. 被调用方返回结果。
  5. 调用方继续执行后续逻辑。

如果被调用方执行时间较长,调用方的执行线程可能长时间处于等待状态。

2. 异步调用机制

异步调用将任务提交和任务完成分开处理。

sequenceDiagram
    participant A as 调用方
    participant B as 异步任务
    participant C as 事件通知机制

    A->>B: 提交任务
    B-->>A: 返回任务句柄
    A->>A: 执行其他工作
    B->>B: 后台处理或等待I/O
    B->>C: 任务完成通知
    C-->>A: 触发回调或恢复任务
    A->>A: 获取结果并继续

执行过程:

  1. 调用方提交任务。
  2. 系统返回任务句柄或异步结果对象。
  3. 调用方继续处理其他工作。
  4. 异步任务在适当的执行机制中推进。
  5. 任务完成后发送通知或更新任务状态。
  6. 调用方获取结果并继续执行。

异步并不意味着任务一定在后台线程执行。任务可以由操作系统异步 I/O、事件循环、线程池、运行时调度器等机制完成。

3. 同步与异步的关键差异

同步调用关注的是:

  • 当前操作什么时候返回?
  • 调用方是否需要等待?
  • 后续逻辑是否依赖当前调用结果?

异步调用关注的是:

  • 任务如何提交?
  • 调用方如何继续执行?
  • 任务完成后如何通知?
  • 结果和异常如何传递?

两者的核心差异不是执行速度,而是任务之间的协调方式。


三、同步不等于阻塞,异步不等于非阻塞

这是理解并发模型时最容易混淆的概念。

同步、异步与阻塞、非阻塞属于不同维度。

1. 阻塞(Blocking)

阻塞描述调用线程在等待某个操作时的状态。

当线程发起操作后,如果操作尚未完成,线程无法继续执行当前任务,就可能进入阻塞等待。

例如:

import socket

sock = socket.socket()
sock.connect(("example.com", 80))

data = sock.recv(1024)

如果当前没有数据可读,阻塞式 recv() 可能使调用线程等待数据到达。

2. 非阻塞(Non-blocking)

非阻塞描述操作在条件尚未满足时,是否立即返回控制权。

例如:

import socket

sock = socket.socket()
sock.setblocking(False)

try:
    data = sock.recv(1024)
except BlockingIOError:
    print("当前没有可读取的数据")

如果数据尚未准备好,非阻塞调用通常立即返回,而不是让线程持续等待。

3. 四种组合关系

同步/异步与阻塞/非阻塞可以组合使用。

类型 调用行为 典型表现
同步阻塞 等待操作完成 阻塞式文件读取
同步非阻塞 立即返回状态,调用方主动检查 非阻塞 Socket 轮询
异步阻塞 异步任务提交后,调用方仍同步等待结果 提交异步任务后调用 join() 等待
异步非阻塞 提交任务后继续执行,完成时接收通知 事件循环、异步 I/O

其中,异步阻塞并不矛盾。例如,一个任务由线程池异步执行,但调用方随后调用 Future.result() 等待结果,调用方仍然发生阻塞。

4. 四种模型示意

flowchart TB
    A["操作调用模型"] --> B["同步"]
    A --> C["异步"]

    B --> D["阻塞"]
    B --> E["非阻塞"]

    C --> F["等待异步结果"]
    C --> G["异步非阻塞"]

    D --> H["操作未完成时线程等待"]
    E --> I["立即返回状态,主动检查"]
    F --> J["任务异步执行,调用方阻塞等待"]
    G --> K["任务完成后通过事件或回调通知"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style J fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style K fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,实际 API 的同步/异步属性应结合结果交付方式和调用方行为判断,不能仅凭函数名称或是否立即返回判断。


四、异步编程的核心机制

异步编程并不是简单地把函数放到后台执行,而是需要一套任务管理、状态推进和结果交付机制。

常见的核心抽象包括:

  1. 回调函数(Callback)。
  2. Future。
  3. Promise。
  4. 事件循环(Event Loop)。
  5. 协程(Coroutine)。
  6. 异步 I/O(Asynchronous I/O)。

1. 回调函数(Callback)

回调函数是任务完成后被调用的函数。

function fetchData(callback) {
    setTimeout(() => {
        callback(null, { name: "Alice" });
    }, 1000);
}

fetchData((error, result) => {
    if (error) {
        console.error(error);
        return;
    }

    console.log(result);
});

调用方将处理结果的逻辑交给回调函数,任务完成后由异步执行机制触发回调。

优点:

  • 实现方式直接。
  • 不需要阻塞等待。
  • 适合简单的事件通知。

缺点:

  • 多层嵌套导致代码结构复杂。
  • 错误传播容易分散。
  • 多任务依赖关系不容易管理。
  • 取消和超时控制较复杂。

2. Future

Future 表示一个尚未完成或已经完成的异步计算结果。

它通常具有以下状态:

  • Pending:任务尚未完成。
  • Completed:任务成功完成。
  • Failed:任务执行失败。
  • Cancelled:任务被取消。

不同语言的 Future API 对取消能力、完成状态和调度策略的定义并不完全一致。

Python 示例:

from concurrent.futures import ThreadPoolExecutor

def calculate():
    return 100

with ThreadPoolExecutor() as executor:
    future = executor.submit(calculate)

    print(future.done())
    result = future.result()

    print(result)

submit() 提交任务并返回 Future。

result() 获取结果时,如果任务尚未完成,调用线程会等待。因此,使用 Future 不代表调用过程天然非阻塞。

3. Promise

Promise 是 JavaScript 中用于表示异步操作最终结果的对象。

Promise 具有三种状态:

状态 含义
Pending 等待完成
Fulfilled 操作成功
Rejected 操作失败

Promise 状态只能从 Pending 转换为 Fulfilled 或 Rejected,完成后不可再次改变。

const promise = new Promise((resolve, reject) => {
    const success = true;

    if (success) {
        resolve("执行成功");
    } else {
        reject(new Error("执行失败"));
    }
});

promise
    .then(result => {
        console.log(result);
    })
    .catch(error => {
        console.error(error);
    });

Promise 解决了传统回调嵌套和错误传播的一部分问题。

它可以通过链式调用组织多个异步操作:

fetch("/api/user")
    .then(response => response.json())
    .then(user => fetch(`/api/orders/${user.id}`))
    .then(response => response.json())
    .then(orders => console.log(orders))
    .catch(error => console.error(error));

4. async / await

async 和 await 是构建在 Promise 等异步结果机制之上的语法抽象。

它们让异步代码具有接近同步代码的阅读结构。

async function getUser() {
    try {
        const response = await fetch("/api/user");

        if (!response.ok) {
            throw new Error("请求失败");
        }

        return await response.json();
    } catch (error) {
        console.error(error);
        throw error;
    }
}

关键语义:

  • async 函数总是返回 Promise。
  • await 等待 Promise 或可等待对象的结果。
  • await 暂停当前 async 函数的后续执行。
  • await 通常不会阻塞 JavaScript 主线程。
  • await 后续代码会在异步结果完成后恢复执行。

需要特别注意:

async function example() {
    const a = await taskA();
    const b = await taskB();

    return [a, b];
}

这里 taskB() 要等 taskA() 完成后才会启动。

如果两个任务互不依赖,可以使用:

async function example() {
    const [a, b] = await Promise.all([
        taskA(),
        taskB()
    ]);

    return [a, b];
}

Promise.all() 可以并发等待多个 Promise,但并不保证这些任务一定在多个 CPU 核心上并行执行。


五、事件循环(Event Loop)

事件循环是许多异步运行时实现任务调度的重要机制。

JavaScript 浏览器环境和 Node.js 都使用事件循环模型,但具体阶段和调度规则存在差异。

1. 事件循环的组成

以浏览器 JavaScript 为例,主要组成包括:

  • 调用栈(Call Stack):执行当前同步代码。
  • Web APIs:浏览器提供的定时器、网络请求等能力。
  • 任务队列(Task Queue):保存等待执行的任务。
  • 微任务队列(Microtask Queue):保存 Promise 回调等微任务。
  • 事件循环(Event Loop):协调调用栈和任务队列。

2. 事件循环执行流程

flowchart TD
    A["执行同步代码"] --> B["调用栈是否为空"]
    B --> C{"是否存在待执行微任务"}
    C -->|是| D["执行微任务"]
    D --> C
    C -->|否| E["浏览器可进行渲染"]
    E --> F["取出一个宏任务"]
    F --> G["执行宏任务"]
    G --> B

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这是浏览器事件循环的简化示意。浏览器还涉及渲染机会、用户交互任务、定时器、网络事件等更复杂的调度规则。

3. 宏任务与微任务

浏览器环境中,常见任务分类如下:

类型 常见来源 特点
宏任务(Task) setTimeout、用户事件、部分 I/O 回调 按任务队列调度
微任务(Microtask) Promise.then、queueMicrotask、MutationObserver 通常在当前任务结束后集中执行

示例:

console.log("1");

setTimeout(() => {
    console.log("2");
}, 0);

Promise.resolve().then(() => {
    console.log("3");
});

console.log("4");

输出:

1
4
3
2

原因:

  1. 同步代码先执行。
  2. 同步代码执行完成后,清空微任务队列。
  3. 后续执行宏任务队列中的定时器任务。

注意:setTimeout(fn, 0) 并不意味着函数立即执行,而是表示在满足调度条件后尽早执行。

4. 微任务中的常见陷阱

微任务执行期间产生的新微任务,通常会继续在当前微任务检查点执行。

如果持续产生微任务,可能导致:

  • 宏任务迟迟得不到执行。
  • 浏览器渲染被延迟。
  • 页面出现卡顿。
  • 事件响应延迟。

因此,不应该在微任务中无限递归地提交新的微任务。


六、异步 I/O 的实现原理

异步 I/O 是高并发网络服务的重要基础。

1. 同步 I/O 模型

传统阻塞式 I/O 中,线程发起读取操作后,如果数据尚未准备好,线程可能一直等待。

sequenceDiagram
    participant A as 应用线程
    participant K as 内核
    participant D as I/O设备

    A->>K: 发起读取请求
    K->>D: 等待设备数据
    Note over A: 调用线程阻塞等待
    D-->>K: 数据准备完成
    K-->>A: 返回读取结果
    Note over A: 继续执行

这种方式容易理解,但大量连接同时等待时,需要消耗较多线程资源。

2. 非阻塞 I/O

非阻塞 I/O 在数据尚未准备好时立即返回。

应用程序可以重复尝试读取,但如果采用频繁轮询,会浪费 CPU 时间。

flowchart TD
    A["发起非阻塞读取"] --> B["检查数据是否就绪"]
    B --> C{"数据是否就绪"}
    C -->|否| D["立即返回未就绪"]
    D --> E["稍后再次检查"]
    E --> B
    C -->|是| F["读取数据"]
    F --> G["处理结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style C fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

3. I/O 多路复用

I/O 多路复用允许一个线程监控多个文件描述符的 I/O 就绪状态。

常见机制:

机制 平台 特点
select 多平台 传统接口,存在描述符数量等限制
poll 多平台 使用数组管理描述符
epoll Linux 高效管理大量连接
kqueue BSD、macOS 事件通知机制
IOCP Windows 完成通知模型

以 Linux epoll 为例:

  1. 应用程序注册需要监控的文件描述符。
  2. 内核维护关注的事件集合。
  3. 文件描述符状态发生变化时,内核记录就绪事件。
  4. 应用程序调用 epoll_wait() 获取就绪事件。
  5. 应用程序处理对应 I/O。
flowchart TD
    A["创建 epoll 实例"] --> B["注册文件描述符"]
    B --> C["内核监控 I/O 事件"]
    C --> D["等待就绪事件"]
    D --> E{"是否有就绪事件"}
    E -->|否| D
    E -->|是| F["返回就绪描述符"]
    F --> G["应用程序处理 I/O"]
    G --> D

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要特别区分:

  • I/O 多路复用通常报告文件描述符是否就绪。
  • 真正的数据读取仍然由应用程序执行。
  • epoll_wait() 本身可能阻塞等待事件。
  • 使用 I/O 多路复用并不自动意味着整个 I/O 操作都是异步完成的。

4. 真正的异步 I/O

真正的异步 I/O 通常由操作系统或运行时负责推进 I/O 操作,完成后再通知应用程序。

应用程序不必在发起操作后持续等待数据准备和读取过程。

不同操作系统提供不同实现,例如:

  • Linux io_uring。
  • Windows IOCP。
  • macOS、BSD 等平台的相关异步 I/O 接口。

但不同接口的完成语义、缓冲区要求和适用范围并不相同。

5. I/O 多路复用与异步 I/O 的区别

比较维度 I/O 多路复用 异步 I/O
核心机制 监控多个 I/O 的就绪状态 提交 I/O 并等待完成通知
内核职责 通知哪些操作可以进行 推进并完成具体 I/O 操作
数据读取 通常由应用程序执行 由异步 I/O 机制完成或协助完成
等待方式 等待就绪事件 等待完成事件
编程模型 事件驱动 完成驱动
典型接口 select、poll、epoll io_uring、IOCP

这一区别非常重要:高性能网络框架常使用 I/O 多路复用构建异步编程接口,但底层并不一定采用操作系统意义上的真正异步 I/O。


七、异步编程与协程

协程(Coroutine)是一种可以暂停和恢复执行的程序执行单元。

它允许任务在遇到等待条件时主动挂起,把执行权交给其他任务,之后再从挂起位置恢复。

1. 协程的核心特征

  • 具有独立的执行状态。
  • 可以在指定位置挂起。
  • 可以在之后恢复执行。
  • 通常由语言运行时或调度器管理。
  • 不一定对应独立操作系统线程。

协程是一种执行抽象,异步是一种任务协作方式,两者有关联,但并不是同一个概念。

2. async / await 与协程

Python 示例:

import asyncio

async def fetch_data():
    print("开始请求")
    await asyncio.sleep(2)
    print("请求完成")
    return {"name": "Alice"}

async def main():
    result = await fetch_data()
    print(result)

asyncio.run(main())

这里:

  • async def 定义协程函数。
  • 调用协程函数会得到协程对象。
  • await 可以等待可等待对象。
  • asyncio 事件循环负责调度协程。
  • asyncio.sleep() 在等待期间挂起当前协程,而不是阻塞整个事件循环线程。

3. 多协程并发执行

import asyncio

async def task(name):
    print(f"{name} 开始")
    await asyncio.sleep(2)
    print(f"{name} 完成")

async def main():
    await asyncio.gather(
        task("任务A"),
        task("任务B"),
        task("任务C")
    )

asyncio.run(main())

三个任务可以在一个事件循环线程中交替推进。

如果它们主要执行 I/O 等待,等待时间可以重叠,从而提高整体吞吐量。

但如果协程中执行大量不让出执行权的 CPU 密集型代码,事件循环就可能被阻塞。

4. 协程、线程与进程的区别

比较维度 协程 线程 进程
执行抽象 轻量级任务 执行流 独立运行实例
调度者 运行时或调度器 操作系统或运行时 操作系统管理其线程
切换成本 通常较低 通常较高 通常更高
地址空间 共享所属执行环境 共享所属进程 通常独立
并行能力 取决于运行时和映射模型 可以多核并行 可以多核并行
典型用途 高并发 I/O 并发执行任务 隔离与独立计算

5. 协程不能自动解决 CPU 密集型问题

例如:

async def cpu_task():
    result = 0

    for i in range(100000000):
        result += i

    return result

这个协程没有执行有效的异步等待点。

当它在事件循环线程中运行时,会持续占用该线程,导致其他协程无法及时执行。

解决方式包括:

  • 将 CPU 密集型任务提交到进程池。
  • 使用线程池执行适合线程处理的任务。
  • 使用专门的计算服务。
  • 使用支持并行执行的运行时或语言机制。

八、同步与异步的性能分析

同步和异步没有绝对的性能优劣,需要结合任务类型、等待时间、并发规模和调度开销判断。

1. CPU 密集型任务

CPU 密集型任务主要消耗处理器计算资源,例如:

  • 图像编码。
  • 视频转码。
  • 数值计算。
  • 加密计算。
  • 大规模数据处理。

这类任务的主要瓶颈是 CPU 计算能力。

异步 I/O 不能直接提高 CPU 计算速度。

如果需要利用多核,应考虑多进程、多线程或专门的并行计算机制。

2. I/O 密集型任务

I/O 密集型任务主要等待外部资源,例如:

  • 网络请求。
  • 数据库查询。
  • 文件读取。
  • 远程服务调用。
  • 消息队列消费。

这类任务的主要瓶颈通常不是 CPU,而是等待 I/O 完成。

异步模型可以让执行线程在等待期间处理其他任务,提升资源利用率。

3. 同步与异步的耗时对比

假设有三个互不依赖的网络请求,每个请求耗时约 2 秒。

同步顺序执行:

flowchart TD
    A["请求 A:2 秒"] --> B["请求 B:2 秒"]
    B --> C["请求 C:2 秒"]
    C --> D["总耗时约 6 秒"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

异步并发执行:

flowchart TD
    A["同时发起请求"] --> B["请求 A:2 秒"]
    A --> C["请求 B:2 秒"]
    A --> D["请求 C:2 秒"]
    B --> E["收集结果"]
    C --> E
    D --> E
    E --> F["总耗时约 2 秒"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px