一、同步与异步的基本概念
同步(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: 继续执行
执行过程:
- 调用方发起请求。
- 被调用方开始处理。
- 调用方等待处理结果。
- 被调用方返回结果。
- 调用方继续执行后续逻辑。
如果被调用方执行时间较长,调用方的执行线程可能长时间处于等待状态。
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: 获取结果并继续
执行过程:
- 调用方提交任务。
- 系统返回任务句柄或异步结果对象。
- 调用方继续处理其他工作。
- 异步任务在适当的执行机制中推进。
- 任务完成后发送通知或更新任务状态。
- 调用方获取结果并继续执行。
异步并不意味着任务一定在后台线程执行。任务可以由操作系统异步 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 的同步/异步属性应结合结果交付方式和调用方行为判断,不能仅凭函数名称或是否立即返回判断。
四、异步编程的核心机制
异步编程并不是简单地把函数放到后台执行,而是需要一套任务管理、状态推进和结果交付机制。
常见的核心抽象包括:
- 回调函数(Callback)。
- Future。
- Promise。
- 事件循环(Event Loop)。
- 协程(Coroutine)。
- 异步 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
原因:
- 同步代码先执行。
- 同步代码执行完成后,清空微任务队列。
- 后续执行宏任务队列中的定时器任务。
注意: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 为例:
- 应用程序注册需要监控的文件描述符。
- 内核维护关注的事件集合。
- 文件描述符状态发生变化时,内核记录就绪事件。
- 应用程序调用
epoll_wait()获取就绪事件。 - 应用程序处理对应 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