返回专栏
· 17 分钟阅读

阻塞与非阻塞


一、阻塞与非阻塞的基本概念

阻塞(Blocking)和非阻塞(Non-blocking)描述的是:当一个操作暂时无法完成时,调用方是否需要等待。

它们关注的是调用线程在操作未完成时的行为,而不是任务是否异步执行,也不是操作最终是否成功。

1. 阻塞(Blocking)

阻塞是指调用方发起操作后,如果操作暂时无法完成,调用线程需要等待,不能继续执行当前调用之后的代码。

例如,使用阻塞式 Socket 接收数据:

import socket

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

data = sock.recv(1024)
print(data)

如果接收缓冲区中没有可读取的数据,recv() 可能一直等待,直到:

  • 数据到达。
  • 连接关闭。
  • 操作发生错误。
  • 超时时间到达(如果设置了超时)。

阻塞期间,线程通常处于等待状态,不会持续占用 CPU 执行用户代码,但线程资源仍然被占用。

2. 非阻塞(Non-blocking)

非阻塞是指调用方发起操作后,如果操作暂时无法完成,接口立即返回控制权,而不是持续等待。

例如:

import socket

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

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

如果数据尚未准备好,recv() 会立即返回,并通过异常或状态码表示当前无法完成读取。

调用方可以继续执行其他任务,稍后再次尝试。

非阻塞调用的核心特征:

  • 不因当前操作未就绪而持续等待。
  • 可以立即返回未完成状态。
  • 调用方需要处理操作尚未就绪的情况。
  • 通常需要配合轮询、事件通知或 I/O 多路复用。

3. 核心区别

比较维度 阻塞 非阻塞
操作未就绪时 等待操作完成 立即返回
调用线程 可能进入等待状态 可以继续执行
结果获取 操作完成后返回结果 可能先返回未就绪状态
编程复杂度 相对简单 需要管理状态和重试
CPU 使用 等待期间通常不消耗大量 CPU 取决于轮询或事件通知方式
并发模型 常配合线程或进程 常配合事件驱动模型
典型场景 阻塞式文件读取、Socket 非阻塞 Socket、事件循环

需要注意:非阻塞并不代表操作一定成功,也不代表操作一定在后台执行。它只保证在操作暂时无法完成时,不让调用线程持续等待。


二、阻塞与非阻塞的执行机制

1. 阻塞调用流程

阻塞式操作通常具有以下执行过程:

  1. 应用程序发起系统调用。
  2. 内核检查操作所需条件。
  3. 如果条件满足,执行操作。
  4. 如果条件不满足,调用线程进入等待状态。
  5. 相关事件发生后,线程被唤醒。
  6. 操作完成并返回结果。

以读取网络数据为例:

flowchart TD
    A["应用程序调用 recv()"] --> B["进入内核"]
    B --> C{"接收缓冲区是否有数据"}
    C -->|是| D["读取数据"]
    C -->|否| E["线程进入等待状态"]
    E --> F["等待网络数据到达"]
    F --> G["线程被唤醒"]
    G --> D
    D --> H["返回读取结果"]
    H --> I["继续执行应用代码"]

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

阻塞等待通常由操作系统内核管理。线程进入等待状态后,调度器可以将 CPU 分配给其他可运行线程。

因此,阻塞并不意味着 CPU 一直空转。

2. 非阻塞调用流程

非阻塞操作在条件不满足时立即返回。

flowchart TD
    A["应用程序调用 recv()"] --> B["进入内核"]
    B --> C{"接收缓冲区是否有数据"}
    C -->|是| D["读取数据"]
    C -->|否| E["立即返回未就绪状态"]
    E --> F["执行其他任务"]
    F --> G["稍后再次检查"]
    G --> B
    D --> H["返回读取结果"]

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

非阻塞操作需要调用方自行管理后续处理。

如果简单地在循环中不断尝试读取,就会产生忙轮询(Busy Polling),导致 CPU 资源浪费。


三、阻塞与非阻塞的本质:等待行为

1. 什么是线程阻塞?

线程阻塞是指线程暂时无法继续执行,需要等待某个条件成立。

常见原因包括:

  • 等待网络数据。
  • 等待磁盘 I/O。
  • 等待互斥锁。
  • 等待条件变量。
  • 等待信号量。
  • 等待其他线程完成。
  • 等待定时器或外部事件。

线程阻塞后,操作系统通常将其从可运行状态移出,直到等待条件满足或发生其他唤醒事件。

2. 阻塞不等于 CPU 空闲

假设一个服务器有 1000 个线程:

  • 900 个线程等待网络数据。
  • 50 个线程等待数据库连接。
  • 50 个线程正在处理请求。

大部分线程虽然没有使用 CPU,但仍然占用线程栈、内核管理结构等资源。

如果线程数量持续增加,可能导致:

  • 内存占用增加。
  • 调度管理成本增加。
  • 上下文切换增多。
  • 线程池耗尽。
  • 系统吞吐量下降。

因此,高并发系统通常需要减少大量线程长期阻塞等待带来的资源消耗。

3. 非阻塞不等于没有等待

非阻塞调用只是不让当前调用线程持续等待。

应用程序仍然需要等待操作真正完成,只是可以将等待过程交给其他机制管理。

例如:

  • 通过 epoll 等待文件描述符就绪。
  • 通过事件循环等待回调。
  • 通过 Future 等待异步结果。
  • 通过操作系统完成通知获取 I/O 结果。

等待并没有消失,而是改变了等待的组织方式。


四、阻塞与非阻塞、同步与异步的区别

这是并发编程中最容易混淆的四个概念。

同步与异步关注任务结果的交付和协作方式。

阻塞与非阻塞关注调用线程是否需要等待操作完成。

两组概念属于不同维度。

1. 同步(Synchronous)

同步表示调用方需要按照操作完成的结果组织后续执行。

典型方式是调用函数并获取返回值。

2. 异步(Asynchronous)

异步表示任务提交与任务完成分离,调用方可以先继续执行其他工作,之后通过通知或结果对象获取结果。

3. 四种组合

类型 调用方行为 典型场景
同步阻塞 等待操作完成并直接获取结果 阻塞式 Socket 读取
同步非阻塞 立即返回状态,主动检查结果 非阻塞 Socket 轮询
异步阻塞 异步提交任务,但调用方阻塞等待结果 提交线程池任务后调用 Future.result()
异步非阻塞 提交任务后继续执行,完成时接收通知 事件循环、回调、异步 I/O

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

例如:

future = executor.submit(task)
result = future.result()

submit() 将任务提交到线程池执行,但 result() 在任务未完成时会阻塞调用线程。

因此,任务虽然由线程池异步执行,调用方却采用了阻塞式等待。


五、阻塞 I/O 与非阻塞 I/O

I/O 是阻塞与非阻塞最典型的应用场景。

1. 阻塞 I/O

阻塞 I/O 的典型特点:

  • 发起读取或写入操作。
  • 数据未准备好时等待。
  • 操作完成后返回结果。
  • 应用程序可以使用简单的顺序代码。

以 Linux 网络 Socket 为例:

#include <sys/socket.h>
#include <stdio.h>

int main() {
    int fd = /* 已连接的 socket */;
    char buffer[1024];

    ssize_t n = recv(fd, buffer, sizeof(buffer), 0);

    if (n > 0) {
        printf("收到 %zd 字节\n", n);
    }

    return 0;
}

如果 Socket 是阻塞模式,recv() 在没有可读取数据时通常会等待。

2. 非阻塞 I/O

将 Socket 设置为非阻塞模式后:

#include <sys/socket.h>
#include <fcntl.h>
#include <errno.h>
#include <stdio.h>

int main() {
    int fd = /* 已连接的 socket */;

    int flags = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flags | O_NONBLOCK);

    char buffer[1024];

    ssize_t n = recv(fd, buffer, sizeof(buffer), 0);

    if (n > 0) {
        printf("收到 %zd 字节\n", n);
    } else if (n < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
        printf("数据暂时未就绪\n");
    }

    return 0;
}

当接收缓冲区没有数据时,recv() 通常立即返回 -1,并将 errno 设置为 EAGAIN 或 EWOULDBLOCK。

具体错误处理还需要考虑连接关闭和其他系统错误。

3. 阻塞 I/O 与非阻塞 I/O 对比

比较维度 阻塞 I/O 非阻塞 I/O
数据未就绪 等待 立即返回
线程状态 可能进入等待 可以继续执行
代码组织 顺序式 状态驱动
事件处理 通常由调用本身等待 通常需要轮询或事件通知
线程资源 每个等待操作可能占用线程 可由少量线程管理多个操作
编程复杂度 较低 较高

需要注意,非阻塞 Socket 并不代表所有系统调用都不会阻塞。例如,DNS 解析、文件系统操作或某些库函数仍可能使用阻塞式实现。


六、忙轮询(Busy Polling)

非阻塞调用如果没有配合合理的事件通知机制,容易产生忙轮询。

1. 忙轮询的工作方式

忙轮询是指程序持续检查某个条件是否满足,而不是进入等待状态。

例如:

while (1) {
    ssize_t n = recv(fd, buffer, sizeof(buffer), 0);

    if (n > 0) {
        process(buffer, n);
        break;
    }

    if (errno == EAGAIN || errno == EWOULDBLOCK) {
        continue;
    }

    break;
}

如果数据迟迟没有到达,程序会不断调用 recv()。

2. 忙轮询的问题

  • 持续消耗 CPU。
  • 大量重复系统调用。
  • 增加系统功耗。
  • 与其他任务竞争处理器资源。
  • 在高并发场景下可能降低整体吞吐量。

3. 忙轮询与事件等待

flowchart TD
    A["非阻塞读取"] --> B{"数据是否就绪"}
    B -->|是| C["读取并处理"]
    B -->|否| D["立即再次轮询"]
    D --> B

    E["注册 I/O 事件"] --> F["等待事件通知"]
    F --> G["收到就绪通知"]
    G --> H["执行非阻塞读取"]
    H --> I{"是否还有数据"}
    I -->|是| H
    I -->|否| F

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

事件等待通常比无节制轮询更节省 CPU。

不过,在极低延迟场景中,经过优化的忙轮询也可能有价值,例如高性能网络、实时交易系统等。它需要用 CPU 资源换取更短的事件响应延迟。


七、I/O 多路复用

I/O 多路复用是非阻塞网络编程中的核心技术。

它允许一个线程同时监控多个文件描述符的 I/O 状态,而不需要为每个连接分配一个独立线程。

1. 为什么需要 I/O 多路复用?

假设服务器需要处理 10000 个网络连接。

传统阻塞模型可能为每个连接分配一个线程。

这种模型容易遇到:

  • 线程数量过多。
  • 线程栈占用大量内存。
  • 调度开销增加。
  • 大量线程长期等待数据。
  • 系统资源利用率下降。

I/O 多路复用将多个连接的就绪状态集中交给内核监控。

2. I/O 多路复用的工作流程

flowchart TD
    A["创建多个 Socket"] --> B["设置为非阻塞模式"]
    B --> C["注册文件描述符"]
    C --> D["内核监控 I/O 状态"]
    D --> E["等待就绪事件"]
    E --> F{"是否有就绪事件"}
    F -->|否| E
    F -->|是| G["返回就绪描述符"]
    G --> H["应用程序执行读取或写入"]
    H --> I["处理业务数据"]
    I --> D

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

核心思想是:

  • 一个线程管理多个 I/O 连接。
  • 内核负责监控文件描述符。
  • 应用程序只处理已经就绪的连接。
  • 避免大量线程因为等待 I/O 而长期阻塞。

3. select

select 是传统 I/O 多路复用接口。

主要特点:

  • 支持多个文件描述符。
  • 通过集合描述需要监控的描述符。
  • 每次调用通常需要重新传入关注集合。
  • 返回后需要遍历检查哪些描述符就绪。
  • 在许多实现中存在文件描述符数量限制。

它的接口兼容性较好,但在大量连接场景下效率和使用体验受到限制。

4. poll

poll 使用数组管理文件描述符。

相较于传统 select:

  • 不依赖固定大小的位图集合。
  • 文件描述符数量限制方式不同。
  • 仍然需要在调用时传入关注集合。
  • 返回后通常需要遍历描述符数组。

当监控的连接数量很大时,遍历成本可能比较明显。

5. epoll

epoll 是 Linux 提供的高效 I/O 事件通知机制。

核心接口:

接口 作用
epoll_create1() 创建 epoll 实例
epoll_ctl() 添加、修改或删除监控事件
epoll_wait() 等待并获取就绪事件

典型流程:

int epfd = epoll_create1(0);

struct epoll_event event;
event.events = EPOLLIN;
event.data.fd = client_fd;

epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &event);

struct epoll_event events[128];

int n = epoll_wait(epfd, events, 128, -1);

for (int i = 0; i < n; i++) {
    int fd = events[i].data.fd;
    // 处理对应文件描述符
}

epoll_wait() 可以阻塞等待事件,也可以通过超时参数控制等待时间。

因此,非阻塞 I/O 与阻塞式事件等待可以同时存在:应用程序使用非阻塞 Socket,而事件循环线程阻塞在 epoll_wait() 上。

6. 水平触发与边缘触发

epoll 支持两种重要事件通知模式。

水平触发(Level Triggered,LT)

只要文件描述符仍然处于就绪状态,后续等待操作仍可能收到通知。

特点:

  • 编程相对简单。
  • 没有一次性读完数据也可以继续收到通知。
  • 更容易处理不完整的数据读取。

边缘触发(Edge Triggered,ET)

只有文件描述符状态发生变化时,才通知应用程序。

特点:

  • 减少重复通知。
  • 通常需要配合非阻塞 I/O。
  • 应用程序必须正确处理就绪状态。
  • 常见做法是持续读取,直到返回 EAGAIN 或 EWOULDBLOCK。