Lanchester Blog

Leave a leaf

0%

Linux I/O模型与线程模型

Posted on Edited on In

网络应用程序框架，高性能之处主要来自于其 I/O 模型和线程处理模型，前者决定如何收发数据，后者决定如何处理数据。根据 UNIX 网络编程的 I/O 模型的分类，UNIX 提供了五种 I/O 模型：阻塞式 I/O 模型（blocking I/O）、非阻塞式 I/O 模型（non-blocking I/O）、I/O 复用模型（I/O multiplexing）、信号驱动式 I/O 模型（signal-driven I/O）、异步 I/O 模型（asynchronous I/O）

服务端处理网络请求的典型过程

由上图可以看到，主要处理步骤包括：

  1. 获取请求数据，客户端与服务器建立连接发出请求，服务器接受请求（1-3）
  2. 构建响应，当服务器接收完请求，并在用户空间处理客户端的请求，直到构建响应完成（4）
  3. 返回数据，服务器将已构建好的响应再通过内核空间的网络 I/O 发还给客户端（5-7）

设计服务端并发模型时，主要有如下两个关键点：

  1. 服务器如何管理连接，获取输入数据
  2. 服务器如何处理请求

IO模型

对于一个输入操作通常包括两个不同的阶段：

  1. 等待数据准备好
  2. 从内核向进程复制数据

对于一个 Socket 上的输入操作也包括两个不同的阶段：

  1. 等待数据从网络中到达。当所等待分组到达时，它被复制到内核中的某个缓冲区
  2. 把数据从内核缓冲区复制到应用进程缓冲区。

阻塞式 I/O 模型（blocking I/O）

在阻塞式 I/O 模型中，应用程序在从调用 recvfrom 开始到它返回有数据报准备好这段时间是阻塞的，recvfrom 返回成功后，应用进程开始处理数据报。

优点：程序简单，在阻塞等待数据期间进程/线程挂起，基本不会占用 CPU 资源。
缺点：每个连接需要独立的进程/线程单独处理，当并发请求量大时为了维护程序，内存、线程切换开销较大，这种模型在实际生产中很少使用。

非阻塞式 I/O 模型（non-blocking I/O）

在非阻塞式 I/O 模型中，应用程序把一个套接口设置为非阻塞，就是告诉内核，当所请求的 I/O 操作无法完成时，不要将进程睡眠。而是返回一个错误，应用程序基于 I/O 操作函数将不断的轮询数据是否已经准备好，如果没有准备好，继续轮询，直到数据准备好为止。

优点：不会阻塞在内核的等待数据过程，每次发起的 I/O 请求可以立即返回，不用阻塞等待，实时性较好。
缺点：轮询将会不断地询问内核，这将占用大量的 CPU 时间，系统资源利用率较低，所以一般 Web 服务器不使用这种 I/O 模型。

I/O 复用模型（I/O multiplexing）

在 I/O 复用模型中，会用到 Select 或 Poll 函数或 Epoll 函数(Linux 2.6 以后的内核开始支持)，这两个函数也会使进程阻塞，但是和阻塞 I/O 有所不同。这两个函数可以同时阻塞多个 I/O 操作，而且可以同时对多个读操作，多个写操作的 I/O 函数进行检测，直到有数据可读或可写时，才真正调用 I/O 操作函数。

优点：可以基于一个阻塞对象，同时在多个描述符上等待就绪，而不是使用多个线程(每个文件描述符一个线程)，这样可以大大节省系统资源。
缺点：当连接数较少时效率相比多线程+阻塞 I/O 模型效率较低，可能延迟更大，因为单个连接处理需要 2 次系统调用，占用时间会有增加。

众所周之，Nginx 这样的高性能互联网反向代理服务器大获成功的关键就是得益于Epoll。

信号驱动式 I/O 模型（signal-driven I/O）

在信号驱动式 I/O 模型中，应用程序使用 Socket 进行信号驱动 I/O，并安装一个信号处理函数，进程继续运行并不阻塞。当数据准备好时，进程会收到一个 SIGIO 信号，可以在信号处理函数中调用 I/O 操作函数处理数据。

优点：线程并没有在等待数据时被阻塞，可以提高资源的利用率。
缺点：信号 I/O 在大量 IO 操作时可能会因为信号队列溢出导致没法通知。

信号驱动 I/O 尽管对于处理 UDP 套接字来说有用，即这种信号通知意味着到达一个数据报，或者返回一个异步错误。

但是，对于 TCP 而言，信号驱动的 I/O 方式近乎无用，因为导致这种通知的条件为数众多，每一个来进行判别会消耗很大资源，与前几种方式相比优势尽失。

异步 I/O 模型（asynchronous I/O）

由 POSIX 规范定义，应用程序告知内核启动某个操作，并让内核在整个操作（包括将数据从内核拷贝到应用程序的缓冲区）完成后通知应用程序。这种模型与信号驱动模型的主要区别在于：信号驱动 I/O 是由内核通知应用程序何时启动一个 I/O 操作，而异步 I/O 模型是由内核通知应用程序 I/O 操作何时完成。

优点：异步 I/O 能够充分利用 DMA 特性，让 I/O 操作与计算重叠。
缺点：要实现真正的异步 I/O，操作系统需要做大量的工作。目前 Windows 下通过 IOCP 实现了真正的异步 I/O。

而在 Linux 系统下，Linux 2.6才引入，目前 AIO 并不完善，因此在 Linux 下实现高并发网络编程时都是以 IO 复用模型模式为主。

五种I/O模型总结

这五种 I/O 模型中，前四种属于同步 I/O，因为其中真正的 I/O 操作(recvfrom)将阻塞进程/线程，只有异步 I/O 模型才与 POSIX 定义的异步 I/O 相匹配。

线程模型

传统阻塞IO服务模型

对应 Blocking IO 模型

特点：

  1. 采用阻塞式 I/O 模型获取输入数据
  2. 每个连接都需要独立的线程完成数据输入，业务处理，数据返回的完整操作

存在问题：

  1. 当并发数较大时，需要创建大量线程来处理连接，系统资源占用较大
  2. 连接建立后，如果当前线程暂时没有数据可读，则线程就阻塞在 Read 操作上，造成线程资源浪费

解决方案：

  1. 基于 I/O 复用模型

    多个连接共用一个阻塞对象，应用程序只需要在一个阻塞对象上等待，无需阻塞等待所有连接。当某条连接有新的数据可以处理时，操作系统通知应用程序，线程从阻塞状态返回，开始进行业务处理

  2. 基于线程池复用线程资源

    不必再为每个连接创建线程，将连接完成后的业务处理任务分配给线程进行处理，一个线程可以处理多个连接的业务

这两种方案的结合就是Reactor模型的基本设计思想

Reactor模式

对应IO复用模型，使用 Reactor 设计模式进行实现

基本介绍

Reactor 模式，是指通过一个或多个输入同时传递给服务处理器的服务请求的事件驱动处理模式。

服务端程序处理传入多路请求，并将它们同步分派给请求对应的处理线程，Reactor 模式也叫 Dispatcher 模式。即 I/O 多了复用统一监听事件，收到事件后分发(Dispatch 给某进程)，是编写高性能网络服务器。

Reactor 模式具有以下优点：

  1. 响应快，不必为单个同步时间所阻塞，虽然 Reactor 本身依然是同步的
  2. 编程相对简单，可以最大程度的避免复杂的多线程及同步问题，并且避免了多线程/进程的切换开销
  3. 可扩展性，可以方便的通过增加 Reactor 实例个数来充分利用 CPU 资源
  4. 可复用性，Reactor 模式本身与具体事件处理逻辑无关，具有很高的复用性。

Reactor 模式中有 2 个关键组成：

  1. Reactor：Reactor 在一个单独的线程中运行，负责监听和分发事件，分发给适当的处理程序来对 IO 事件做出反应。 它就像公司的电话接线员，它接听来自客户的电话并将线路转移到适当的联系人
  2. Handlers：处理程序执行 I/O 事件要完成的实际事件，类似于客户想要与之交谈的公司中的实际官员。Reactor 通过调度适当的处理程序来响应 I/O 事件，处理程序执行非阻塞操作。

Reactor模式的变种

根据 Reactor 的数量和处理资源池线程的数量不同，有 3 种典型的实现：

  1. 单 Reactor 单线程（Acceptor Worker 共用同一个 NIO 线程）
  2. 单 Reactor 多线程（单 Acceptor 多 Worker）
  3. 主从 Reactor 多线程（多Acceptor 多 Worker）

单Reactor单线程

Reactor 单线程模式，是指所有的 IO 操作都在同一个 NIO 线程上面完成。

其中，Select 是前面 I/O 复用模型介绍的标准网络编程 API，可以实现应用程序通过一个阻塞对象监听多路连接请求，其他方案示意图类似。

方案说明

  1. Reactor 对象通过 Select 监控客户端请求事件，收到事件后通过 Dispatch 进行分发
  2. 如果是建立连接请求事件，则由 Acceptor 通过 Accept 处理连接请求，然后创建一个 Handler 对象处理连接完成后的后续业务处理
  3. 如果不是建立连接事件，则 Reactor 会分发调用连接对应的 Handler 来响应
  4. Handler 会完成 Read→业务处理→Send 的完整业务流程。

优点

模型简单，没有多线程、进程通信、竞争的问题，全部都在一个线程中完成。

由于 Reactor 模式使用的是异步非阻塞 I/O，所有的I/O操作都不会导致阻塞，理论上个线程可以独立处理所有 I/O 相关的操作。从架构层面看，一个 NIO 线程确实可以完成其承担的职责。通过 Acceptor 类接收客户端的 TCP 连接请求消息，当链路建立成功之后，通过 Dispatch 将对应的 ByteBuffer 派发到指定的 Handler 上，进行消息解码。用户线程消息编码后通过 NIO 线程将消息发送给客户端。

缺点

性能问题，只有一个线程，无法完全发挥多核 CPU 的性能。Handler 在处理某个连接上的业务时，整个进程无法处理其他连接事件，很容易导致性能瓶颈。

可靠性问题，线程意外跑飞，或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障。

使用场景

在一些小容量应用场景下，可以使用单线程模式。但是这对于高负载、大并发的应用场景却不合适，主要原因如下：

  1. 一个 NlO 线程同时处理成百上千的链路，性能上无法支撑，即便 NIO 线程的 CPU 负荷达到100%，也无法满足海量消息的编码、解码、读取和发送。
  2. 当 NIO 线程负载过重之后，处理速度将变慢，这会导致大量客户端连接超时，超时之后往往会进行重发，这更加重了 NIO 线程的负载，最终会导致大量消息积压和处理超时，成为系统的性能瓶颈。
  3. 可靠性问题：一旦 NlO 线程意外跑飞，或者进入死循环，会导致整个系统通信模块不可用，不能接收和处理外部消息，造成节点故障。

或者在客户端的数量有限，业务处理非常快速的场景下，比如 Redis，业务处理的时间复杂度 O(1)。

单Reactor多线程

Reactor 多线程模式与单线程模式最大的区别就是有一组 NIO 线程来处理 IO 操作。

Reactor多线程模式的特点如下：

  1. 有专门一个 NIO 线程 —— Acceptor 线程用于监听服务端，接收客户端的 TCP 连接请求。
  2. 网络 IO 操作 —— 读、写等由一个 NIO 线程池负责，线程池可以采用标准的 JDK 线程池实现，它包含一个任务队列和 N 个可用的线程，由这些 NIO 线程负责消息的读取、解码、编码和发送。
  3. 一个 NIO 线程可以同时处理 N 条链路，但是一个链路只对应一个 NIO 线程，防止发生并发操作问题。

方案说明：

  1. Reactor 对象通过 Select 监控客户端请求事件，收到事件后通过 Dispatch 进行分发
  2. 如果是建立连接请求事件，则由 Acceptor 通过 Accept 处理连接请求，然后创建一个 Handler 对象处理连接完成后续的各种事件
  3. 如果不是建立连接事件，则 Reactor 会分发调用连接对应的 Handler 来响应
  4. Handler 只负责响应事件，不做具体业务处理，通过 Read 读取数据后，会分发给后面的 Worker 线程池进行业务处理
  5. Worker 线程池会分配独立的线程完成真正的业务处理，如何将响应结果发给 Handler 进行处理
  6. Handler 收到响应结果后通过 Send 将响应结果返回给 Client

优点

可以充分利用多核 CPU 的处理能力。

在绝大多数场景下，Reactor 多线程模型可以满足性能需求。但是，在个别特殊场景中，一个 NIO 线程负责监听和处理所有的客户端连接可能会存在性能问题。例如并发百万客户端连接，或者服务端需要对客户端握手进行安全认证，但是认证本身非常损耗性能。在这类场景下，单独一个 Acceptor 线程可能会存在性能不足的问题，为了解决性能问题，产生了第三种 Reactor 线程模型——主从 Reactor 多线程模型

缺点

多线程数据共享和访问比较复杂；Reactor 承担所有事件的监听和响应，在单线程中运行，高并发场景下容易成为性能瓶颈。

主从Reactor多线程

主从 Reactor 线程模式的特点是：服务端用于接收客户端连接的不再是一个单独的 NIO 线程，而是一个独立的 NIO 线程池。Acceptor 接收到客户端 TCP 连接请求并处理完成后（可能包含接入认证等），将新创建的 SocketChannel 注册到 IO 线程池（ SubReactor 线程池）的某个 IO 线程上，由它负责 SocketChannel 的读写和编解码工作。Acceptor 线程池仅仅用于客户端的登录、握手和安全认证，一旦链路建立成功，就将链路注册到后端 subReactor 线程池的 IO 线程上，由 IO 线程负责后续的IO操作。

方案说明：

  1. Reactor 主线程 MainReactor 对象通过 Select 监控建立连接事件，收到事件后通过 Acceptor 接收，处理建立连接事件
  2. Acceptor 处理建立连接事件后，MainReactor 将连接分配 Reactor 子线程给 SubReactor 进行处理
  3. SubReactor 将连接加入连接队列进行监听，并创建一个 Handler 用于处理各种连接事件
  4. 当有新的事件发生时，SubReactor 会调用连接对应的 Handler 进行响应
  5. Handler 通过 Read 读取数据后，会分发给后面的 Worker 线程池进行业务处理
  6. Worker 线程池会分配独立的线程完成真正的业务处理，如何将响应结果发给 Handler 进行处理
  7. Handler 收到响应结果后通过 Send 将响应结果返回给 Client

优点：

父线程与子线程的数据交互简单职责明确，父线程只需要接收新连接，子线程完成后续的业务处理。父线程与子线程的数据交互简单，Reactor 主线程只需要把新连接传给子线程，子线程无需返回数据。

这种模式在许多项目中广泛使用，包括 Nginx 主从 Reactor 多进程模式，Memcached 主从多线程模式，Netty 主从多线程模式的支持。

Proactor模式

对应 Asynchronous IO 模型，使用 Proactor 设计模式进行实现

在 Reactor 模式中，Reactor 等待某个事件或者可应用或者操作的状态发生（比如文件描述符可读写，或者是 Socket 可读写）。然后把这个事件传给事先注册的 Handler（事件处理函数或者回调函数），由后者来做实际的读写操作。其中的读写操作都需要应用程序同步操作，所以 Reactor 是非阻塞同步网络模型。

如果把 I/O 操作改为异步，即交给操作系统来完成就能进一步提升性能，这就是异步网络模型 Proactor。

Proactor 是和异步 I/O 相关的，详细方案如下：

  1. Proactor Initiator 创建 Proactor 和 Handler 对象，并将 Proactor 和 Handler 都通过 AsyOptProcessor（Asynchronous Operation Processor）注册到内核
  2. AsyOptProcessor 处理注册请求，并处理 I/O 操作
  3. AsyOptProcessor 完成 I/O 操作后通知 Proactor
  4. Proactor 根据不同的事件类型回调不同的 Handler 进行业务处理
  5. Handler 完成业务处理

可以看出 Proactor 和 Reactor 的区别：

  1. Reactor 是在事件发生时就通知事先注册的事件（读写在应用程序线程中处理完成）；
  2. Proactor 是在事件发生时基于异步 I/O 完成读写操作（由内核完成），待 I/O 操作完成后才回调应用程序的处理器来进行业务处理。

理论上 Proactor 比 Reactor 效率更高，异步 I/O 更加充分发挥 DMA(Direct Memory Access，直接内存存取)的优势。

但是 Proactor 有如下缺点：

  1. 编程复杂性，由于异步操作流程的事件的初始化和事件完成在时间和空间上都是相互分离的，因此开发异步应用程序更加复杂。应用程序还可能因为反向的流控而变得更加难以 Debug
  2. 内存使用，缓冲区在读或写操作的时间段内必须保持住，可能造成持续的不确定性，并且每个并发操作都要求有独立的缓存，相比 Reactor 模式，在 Socket 已经准备好读或写前，是不要求开辟缓存的
  3. 操作系统支持，Windows 下通过 IOCP 实现了真正的异步 I/O，而在 Linux 系统下，Linux 2.6 才引入，目前异步 I/O 还不完善。

因此在 Linux 下实现高并发网络编程都是以 Reactor 模型为主。