关于linux:Java-并发编程解析-如何正确理解线程机制中常见的IO模型各自主要用来解决什么问题

天穹之边，浩瀚之挚，眰恦之美；悟心悟性，虎头蛇尾，惟善惟道！—— 朝槿《朝槿兮年说》

写在结尾

作为一名 Java Developer，咱们都分明地晓得，次要从搭载 Linux 零碎上的服务器程序来说，应用 Java 编写的是”单过程 - 多线程 ” 程序, 而用 C ++ 语言编写的，可能是“单过程 - 多线程”程序，“多过程 - 单线程”程序或者是“多过程 - 多线程”程序。

从肯定水平上 来说，次要因为 Java 程序并不间接运行在 Linux 零碎上，而是运行在 JVM(Java 虚拟机)上，而一个 JVM 实例是一个 Linux 过程，每一个 JVM 都是一个独立的“沙盒”，JVM 之间互相独立，互不通信。

所以，Java 程序只能在这一个过程外面，开发多个线程实现并发，而 C ++ 间接运行在 Linux 零碎上，能够间接利用 Linux 零碎提供的弱小的过程间通信(Inter-Process Communication，IPC), 很容易创立多个过程，并实现过程间通信。

当然，咱们能够明确的是，“多过程 - 多线程”程序是”单过程 - 多线程 ” 程序和“多过程 - 单线程”程序的组合体。无论是 C ++ 开发者在 Linux 零碎中应用的 pthread，还是 Java 开发者应用的 java.util.concurrent(JUC)库，这些线程机制的都须要肯定的线程 I / O 模型来做实践撑持。

所以，接下来，咱们就让咱们一起探讨和揭开常见的线程 I / O 模型的神秘面纱，针对那些盘根错落的枝末细节，能力让咱们更好地理解和正确认识 ava 畛域中的线程机制。

根本概述

I/ O 模型是指计算机波及 I / O 操作时应用到的模型。

个别剖析 Java 畛域中的线程 I / O 模型是何物时，须要先了解一下什么是 I / O 模型？

I/ O 模型是为解决各种问题而提出的，与之相干的概念有线程(Thread)，阻塞(Blocking)，非阻塞(Non-Blocking)，同步(Synchronous) 和异步(Asynchronous) 等。

依照肯定意义上说，I/ O 模型能够分为阻塞 I /O(Blocking IO，BIO)，非阻塞 I /O(Non-Blocking IO，NIO)两大类。

当然，须要留神的是，计算机的 I / O 还包含各种设施的 I /O，比方网络 I /O，磁盘 I /O，键盘 I / O 和鼠标 I / O 等。

一般来说，程序在执行 I / O 操作时，须要从内核空间复制数据，然而内核空间的数据须要较长时间的的筹备，由此可能会导致用户空间产生阻塞。

应用程序处于用户空间，一个应用程序对应着一个过程，而过程中蕴含了缓冲区(Buffer)，因而这里又对应着一个缓冲 I /O(Buffered I/O)，其中：

• 当须要进行 I / O 操作时，须要通过内核空间来执行相应的操作，比方，内核空间负责于键盘，磁盘，网络等控制器进行通信。
• 当内核空间失去不同设施的控制器发送过去的数据后，会将数据复制到用户空间提供给用户程序应用。

由此可见，I/ O 模型 是人与计算机实现沟通和交换的次要通信模型。

特地留神的是，这里的尤其指出网络 I / O 模型。因为网络 I / O 模型存在诸多概念性的货色，有操作系统层面的，也有应用层架构层面的，在不同的层面示意的意思也千差万别，须要咱们认真甄别。

在网路 I / O 模型中，咱们会常常听到阻塞和非阻塞，同步和异步等相干的概念，而且也会混同这个概念，其中最常见的三个问题：

• 首先，认为非阻塞 I /0(Non-Blocking IO) 和异步 I /O(Asynchronous IO) 是同一个概念
• 其次，认为 Linux 零碎中的 select，poll，epoll 等这类 I / O 多路复用是异步 I /O(Asynchronous IO) 模型
• 最初，存在一种 I / O 模型叫异步阻塞 I /O(Asynchronous Blocking IO))模型，实际上并没有这种模型

由此可见，其实造成这三个问题的次要起因就是，咱们在探讨的时候，有的是站在 Linux 操作系统层面说的，有的是站在在 Java 的 JDK 层面来说的，甚至有的是站在下层框架 (中间件 Netty，Tomcat，Nginx，C++ 中的 asio) 封装的模型来说的。

综上所述，针对于不同的层面，须要咱们认真辨析和甄别，这能力让咱们了解得更加透彻。

Linux 操作系统中的 I / O 模型

当初操作系统都是采纳虚拟存储器，那么对 32 位操作系统而言，它的寻址空间（虚拟存储空间）为 4G（2 的 32 次方）。

操心零碎的外围是内核，独立于一般的应用程序，能够拜访受爱护的内存空间，也有拜访底层硬件设施的所有权限。

针对 linux 操作系统而言，为了保障用户过程不能间接操作内核，保障内核的平安，操心零碎将虚拟空间划分为两局部，一部分为内核空间，一部分为用户空间。其中：

• 内核空间(Kernel Space)：将最高的 1G 字节（从虚拟地址 0xC0000000 到 0xFFFFFFFF），供内核应用，是 Linux 内核的运行空间。
• 用户空间(User Space)：将较低的 3G 字节（从虚拟地址 0x00000000 到 0xBFFFFFFF），供各个过程应用，是用户程序的运行空间。

每个过程能够通过零碎调用进入内核，因而，Linux 内核由零碎内的所有过程共享。

于是，从具体过程的角度来看，每个过程能够领有 4G 字节的虚拟空间，其中内核空间和用户空间是隔离的，即便用户的程序解体，内核也不受影响。

然而，在 CPU 的所有指令中，有些指令是十分危险的，如果错用，将导致系统解体，比方清内存、设置时钟等。如果容许所有的程序都能够应用这些指令，那么零碎解体的概率将大大增加。

因为 CPU 将指令分为特权指令和非特权指令，对于那些危险的指令，只容许操作系统及其相干模块应用，一般应用程序只能应用那些不会造成劫难的指令。比方 Intel 的 CPU 将特权等级分为 4 个级别：Ring0~Ring3。

其实 Linux 零碎只应用了 Ring0 和 Ring3 两个运行级别(Windows 零碎也是一样的)。当过程运行在 Ring3 级别时被称为运行在用户态，而运行在 Ring0 级别时被称为运行在内核态。

由此可见，因为有了用户空间和内核空间概念，其 linux 内部结构能够分为三局部，从最底层到最上层顺次是：硬件(Hardware Platfrom)–> 内核空间(Kernel Space)–> 用户空间(User Space)。

(一). 根本定义

因为，应用程序处于用户空间，一个应用程序对应着一个过程，当须要进行 I / O 操作时，须要通过内核空间来执行相应的操作，而当内核空间失去不同设施的控制器发送过去的数据后，会将数据复制到用户空间提供给用户程序应用。

其间示意着，会有一个过程切换的动作，次要概念就是：当过程运行在内核空间时就处于内核态，而过程运行在用户空间时则处于用户态，其中：

• 在内核态下，过程运行在内核地址空间中，此时 CPU 能够执行任何指令。运行的代码也不受任何的限度，能够自在地拜访任何无效地址，也能够间接进行端口的拜访。
• 在用户态下，过程运行在用户地址空间中，被执行的代码要受到 CPU 的诸多查看，它们只能拜访映射其地址空间的页表项中规定的在用户态下可拜访页面的虚拟地址，且只能对工作状态段 (TSS) 中 I/O 许可位图 (I/O Permission Bitmap) 中规定的可拜访端口进行间接拜访。

然而，对于以前的 DOS 操作系统来说，是没有内核空间、用户空间以及内核态、用户态这些概念的。能够认为所有的代码都是运行在内核态的，因此用户编写的利用程序代码能够很容易的让操作系统解体掉。

而对于 Linux 来说，通过辨别内核空间和用户空间的设计，隔离了操作系统代码 (操作系统的代码要比应用程序的代码强壮很多) 与利用程序代码。即使是单个应用程序呈现谬误也不会影响到操作系统的稳定性，这样其它的程序还能够失常的运行。

所以，辨别内核空间和用户空间实质上是要进步操作系统的稳定性及可用性，而过程切换是为了管制过程的执行，内核必须有能力挂起正在 CPU 上运行的过程，并复原以前挂起的某个过程的执行。

个别状况下，任何过程都是在操作系统内核的反对下运行的，是与内核严密相干的。

从一个过程的运行转到另一个过程上运行，这个过程中根本会做如下操作：

• 保留处理器上下文，包含程序计数器和其余寄存器。
• 更新 PCB 信息
• 把过程的 PCB 移入相应的队列，如就绪、在某事件阻塞等队列
• 抉择另一个过程执行，并更新其 PCB
• 更新内存治理的数据结构
• 复原处理器上下文

特地须要留神的是，过程切换势必要思考调用者期待被调用者返回调用后果时的状态和音讯告诉机制、状态等问题，这个其实就是对应阻塞与非阻塞，同步与异步的关怀的实质问题：

• 首先，对于阻塞与非阻塞的角度来说，是调用者期待被调用者返回调用后果时的状态：

  • 阻 塞：调用后果返回之前，调用者会被挂起（不可中断睡眠态），调用者只有在失去返回后果之后能力持续；
  • 非阻塞：调用者在后果返回之前，不会被挂起；即调用不会阻塞调用者，调用者能够持续解决其余的工作；

• 其次，对于同步与异步的角度来说，关注的是音讯告诉机制、状态：

  • 同 步：调用收回之后不会立刻返回，但一旦返回则是最终后果；
  • 异 步：调用收回之后，被调用方立刻返回音讯，但返回的并非最终后果；被调用者通过状态、告诉机制等来告诉调用者，会通过回调函数解决；

综上所述，这便为咱们了解和把握 Linux 零碎中 I /O 模型奠定了根底。接下来，咱们次要来看看 Linux 零碎中的网路 I /O 模型和文件操作 I/O 模型。

(二). 网路 I /O 模型

Linux 的内核将所有外部设备都看做一个文件来操作（所有皆文件），对一个文件的读写操作会调用内核提供的系统命令，返回一个 file descriptor（fd，文件描述符）。而对一个 socket 的读写也会有响应的描述符，称为 socket fd（socket 文件描述符），描述符就是一个数字，指向内核中的一个构造体（文件门路，数据区等一些属性）。

依据 UNIX 网络编程对 I / O 模型的分类来说，Linux 零碎中的网路 I /O 模型次要分为同步阻塞 IO(Blocking I/O,BIO)，同步非阻塞 IO(Non-Blocking I/O,NIO)，IO 多路复用 (I/O Multiplexing)，异步 IO(Asynchronous I/O,AIO) 以及信号驱动式 I /O(Signal-Driven I/O)等 5 种模型，其中：

1. 同步阻塞 IO(BIO)

同步阻塞式 I /O(BIO)模型是最罕用的一个模型，也是最简略的模型。默认状况下，所有文件操作都是阻塞的。

在 Linux 中，同步阻塞式 I /O(BIO)模型下，所有的套接字默认状况下都是阻塞的。

比方 I / O 模型下的套接字接口：在过程空间中调用 recvfrom，其零碎调用直到数据包达到且被复制到利用过程的缓冲区中或者产生谬误时才返回，在此期间始终期待。

过程在调用 recvfrom 开始到它返回的整段工夫内都是被阻塞的，所以叫阻塞 I / O 模型。

过程在向内核调用执行 recvfrom 操作时阻塞，只有当内核将磁盘中的数据复制到内核缓冲区（内核内存空间），并实时复制到过程的缓存区结束后返回；或者产生谬误时（零碎调用信号被中断）返回。

在加载数据到数据复制实现，整个过程都是被阻塞的，不能解决的别的 I /O，此时的过程不再生产 CPU 工夫，而是期待响应的状态，从解决的角度来看，这是十分无效的。

这种 I / O 模型下，执行的两个阶段过程都是阻塞的，其中：

• 第一阶段（阻塞）：
  ①：过程向内核发动零碎调用（recvfrom）；当过程发动调用后，过程开始挂起（过程进入不可中断睡眠状态），过程始终处于期待内核处理结果的状态，此时的过程不能解决其余 I /O，亦被阻塞。
  ②：内核收到过程的零碎调用申请后，此时的数据包并未筹备好，此时内核亦不会给过程发送任何音讯，直到磁盘中的数据加载至内核缓冲区；

• 第二阶段（阻塞）：
  ③：内核再将内核缓冲区中的数据复制到用户空间中的过程缓冲区中（真正执行 IO 过程的阶段），直到数据复制实现。
  ④：内核返回胜利数据处理实现的指令给过程；过程在收到指令后再对数据包过程解决；解决实现后，此时的过程解除不可中断睡眠态，执行下一个 I / O 操作。

  综上所述，在 Linux 中，同步阻塞式 I /O(BIO)模型最典型的代表就是阻塞形式下的 read/write 函数调用。

2. 同步非阻塞 IO(NIO)

同步非阻塞 IO(NIO)模型是过程在调用 recvfrom 从应用层到内核的时候，就间接返回一个 WAGAIN 标识或 EWOULDBLOCK 谬误，个别都对非阻塞 I / O 模型进行轮询查看这个状态，看内核是不是有数据到来。

在 Linux 中，同步非阻塞 IO(NIO)模型模型下，过程在向内核调用函数 recvfrom 执行 I / O 操作时，socket 是以非阻塞的模式关上的。

也就是说，过程进行零碎调用后，内核没有筹备好数据的状况下，会立刻返回一个错误码，阐明过程的零碎调用申请不会立刻满足。

在过程发动 recvfrom 零碎调用时，过程并没有被阻塞，内核马上返回了一个 error。

过程在收到 error，能够解决其余的事物，过一段时间在次发动 recvfrom 零碎调用；其一直的反复发动 recvfrom 零碎调用，这个过程即为过程轮询（polling）。

轮询的形式向内核申请数据，直到数据筹备好，再复制到用户空间缓冲区，进行数据处理。

须要留神的是，复制过程中过程还是阻塞的。

个别状况下，过程采纳轮询（polling）的机制检测 I / O 调用的操作后果是否已实现，会耗费大量的 CPU 时钟周期，性能上并不一定比阻塞式 I / O 高。

这种 I / O 模型下，执行的第一阶段过程都是非阻塞的，第二阶段过程都是阻塞的，其中：

• 第一阶段（非阻塞）：
  ①：过程向内核发动 IO 调用申请，内核接管到过程的 I / O 调用后筹备解决并返回“error”的信息给过程；尔后每隔一段时间过程都会想内核发动询问是否已解决完，即轮询，此过程称为为忙期待；
  ②：内核收到过程的零碎调用申请后，此时的数据包并未筹备好，此时内核会给过程发送 error 信息，直到磁盘中的数据加载至内核缓冲区；
• 第二阶段（阻塞）：
  ③：内核再将内核缓冲区中的数据复制到用户空间中的过程缓冲区中（真正执行 IO 过程的阶段，过程阻塞），直到数据复制实现。
  ④：内核返回胜利数据处理实现的指令给过程；过程在收到指令后再对数据包过程解决；

综上所述，在 Linux 中，同步非阻塞 IO(NIO)模型模型最典型的代表就是以 O_NONBLOCK 参数关上 fd，而后执行 read/write 函数调用。

3.IO 多路复用(I/O Multiplexing)

IO 多路复用 (I/O Multiplexing) 模型也被称为事件驱动式 I / O 模型（Event Driven I/O），Linux 提供 select/poll，过程通过将一个或多个 fd 传递给 select 或 poll 零碎调用，阻塞在 select 操作上，这样，select/poll 能够帮咱们侦测多个 fd 是否处于就绪状态。select/poll 是程序扫描 fd 是否就绪，而且反对的 fd 数量无限，因而它的应用受到了一些制约。Linux 还提供一个 epoll 零碎调用，epoll 应用基于事件驱动形式代替程序扫描，因而性能更高。当有 fd 就绪时，立刻回调函数 rollback。

在 Linux 中，IO 多路复用 (I/O Multiplexing) 模型模型下，每一个 socket，个别都会设置成 non-blocking。

过程通过调用内核中的 select()、poll()、epoll()函数发动零碎调用申请。

selec/poll/epoll 相当于内核中的代理，过程所有的申请都会先申请这几个函数中的某一个；此时，一个过程能够同时解决多个网络连接的 I /O。

select/poll/epoll 这个函数会一直的轮询（polling）所负责的 socket，当某个 socket 有数据报筹备好了（意味着 socket 可读），就会返回可读的告诉信号给过程。

用户过程调用 select/poll/epoll 后，过程实际上是被阻塞的，同时，内核会监督所有 select/poll/epoll 所负责的 socket，当其中任意一个数据筹备好了，就会告诉过程。

只不过过程是阻塞在 select/poll/epoll 之上，而不是被内核筹备数据过程中阻塞。

此时，过程再发动 recvfrom 零碎调用，将数据中内核缓冲区拷贝到内核过程，这个过程是阻塞的。

尽管 select/poll/epoll 能够使得过程看起来是非阻塞的，因为过程能够解决多个连贯，然而最多只有 1024 个网络连接的 I /O；实质上过程还是阻塞的，只不过它能够解决更多的网络连接的 I / O 而已。

这种 I / O 模型下，执行的第一阶段过程都是阻塞的，第二阶段过程都是阻塞的，其中：

• 第一阶段（阻塞在 select/poll 之上）：
  ①：过程向内核发动 select/poll 的零碎调用，select 将该调用告诉内核开始筹备数据，而内核不会返回任何告诉音讯给过程，但过程能够持续解决更多的网络连接 I /O；
  ②：内核收到过程的零碎调用申请后，此时的数据包并未筹备好，此时内核亦不会给过程发送任何音讯，直到磁盘中的数据加载至内核缓冲区；而后通过 select()/poll()函数将 socket 的可读条件返回给过程
• 第二阶段（阻塞）：
  ③：过程在收到 SIGIO 信号程序之后，过程向内核发动零碎调用（recvfrom）；
  ④：内核再将内核缓冲区中的数据复制到用户空间中的过程缓冲区中（真正执行 IO 过程的阶段），直到数据复制实现。
  ⑤：内核返回胜利数据处理实现的指令给过程；过程在收到指令后再对数据包过程解决；解决实现后，此时的过程解除不可中断睡眠态，执行下一个 I / O 操作。

4. 异步 IO(AIO)

异步 IO(AIO)模型是告知内核启动某个操作，并让内核在整个操作实现后（包含数据的复制）告诉过程。信号驱动 I / O 模型告诉的是何时能够开始一个 I / O 操作，异步 I / O 模型有内核告诉 I / O 操作何时曾经实现。

在 Linux 中，异步 IO(AIO)模型中，过程会向内核申请 air_read（异步读）的零碎调用操作，会把套接字描述符、缓冲区指针、缓冲区大小和文件偏移一起发给内核，当内核收到后会返回“已收到”的音讯给过程，此时过程能够持续解决其余 I / O 工作。

也就是说，在第一阶段内核筹备数据的过程中，过程并不会被阻塞，会继续执行。

第二阶段，当数据报筹备好之后，内核会负责将数据报复制到用户过程缓冲区，这个过程也是由内核实现，过程不会被阻塞。

复制实现后，内核向过程递交 aio_read 的指定信号，过程在收到信号后进行解决并解决数据报向外发送。

在过程发动 I / O 调用到收到后果的过程，过程都是非阻塞的。

从肯定水平上说，异步 IO(AIO)模型能够说是在信号驱动式 I / O 模型的一个特例。

这种 I / O 模型下，执行的第一阶段过程都是非阻塞的，第二阶段过程都是非阻塞的，其中：

• 第一阶段（非阻塞）：
  ①：过程向内核申请 air_read（异步读）的零碎调用操作，会把套接字描述符、缓冲区指针、缓冲区大小和文件偏移一起发给内核，当内核收到后会返回“已收到”的音讯给过程
  ②：内核将磁盘中的数据加载至内核缓冲区，直到数据报筹备好；
• 第二阶段（非阻塞）：
  ③：内核开始复制数据，将筹备好的数据报复制到过程内存空间，晓得数据报复制实现
  ④：内核向过程递交 aio_read 的返回指令信号，告诉过程数据已复制到过程内存中

5. 信号驱动式 I /O(Signal-Driven I/O)

信号驱动式 I /O(Signal-Driven I/O)模型是指首先开启套接口信号驱动 I / O 性能，并通过零碎调用 sigaction 执行一个信号处理函数（此零碎调用立刻返回，过程持续工作，非阻塞）。当数据准备就绪时，就为改过程生成一个 SIGIO 信号，通过信号回调告诉应用程序调用 recvfrom 来读取数据，并告诉主循环函数解决建立。

在 Linux 中，信号驱动式 I /O(Signal-Driven I/O)模型中，过程事后告知内核，使得某个文件描述符上产生了变动时，内核应用信号告诉该过程。

在信号驱动式 I / O 模型，过程应用 socket 进行信号驱动 I /O，并建设一个 SIGIO 信号处理函数。

当过程通过该信号处理函数向内核发动 I / O 调用时，内核并没有筹备好数据报，而是返回一个信号给过程，此时过程能够持续发动其余 I / O 调用。

也就是说，在第一阶段内核筹备数据的过程中，过程并不会被阻塞，会继续执行。

当数据报筹备好之后，内核会递交 SIGIO 信号，告诉用户空间的信号处理程序，数据已筹备好；此时过程会发动 recvfrom 的零碎调用，这一个阶段与阻塞式 I / O 无异。

也就是说，在第二阶段内核复制数据到用户空间的过程中，过程同样是被阻塞的。

这种 I / O 模型下，执行的第一阶段过程都是非阻塞的，第二阶段过程都是阻塞的，其中：

• 第一阶段（非阻塞）：
  ①：过程应用 socket 进行信号驱动 I /O，建设 SIGIO 信号处理函数，向内核发动零碎调用，内核在未筹备好数据报的状况下返回一个信号给过程，此时过程能够持续做其余事件
  ②：内核将磁盘中的数据加载至内核缓冲区实现后，会递交 SIGIO 信号给用户空间的信号处理程序；
• 第二阶段（阻塞）：
  ③：过程在收到 SIGIO 信号程序之后，过程向内核发动零碎调用（recvfrom）；
  ④：内核再将内核缓冲区中的数据复制到用户空间中的过程缓冲区中（真正执行 IO 过程的阶段），直到数据复制实现。
  ⑤：内核返回胜利数据处理实现的指令给过程；过程在收到指令后再对数据包过程解决；解决实现后，此时的过程解除不可中断睡眠态，执行下一个 I / O 操作。

(三). 文件操作 I/O 模型

在 Linux 零碎中的网路 I /O 模型，依照文件操作 IO 来说，次要分为缓冲 IO(Buffered I/O)，间接 IO(Direct I/O)，内存映射 (Memory-Mapped,mmap)，零拷贝(Zero Copy) 等 4 种模型，其中：

1. 缓冲 IO(Buffered I/O)

缓冲 IO(Buffered I/O) 是指在内存里开拓一块区域里寄存的数据，次要用来接管用户输出和用于计算机输入的数据以减小零碎开销和进步外设效率的缓冲区机制。

缓存 I / O 又被称作规范 I /O，大多数文件系统的默认 I / O 操作都是缓存 I /O。在 Linux 的缓存 I / O 机制中，数据先从磁盘复制到内核空间的缓冲区，而后从内核空间缓冲区复制到应用程序的地址空间。

总的来说，缓冲区是内存空间的一部分，在内存中预留了肯定的存储空间，用来临时保留输出和输入等 I / O 操作的一些数据，这些预留的空间就叫做缓冲区。

而 buffer 缓冲区和 Cache 缓存区都属于缓冲区的一种 buffer 缓冲区存储速度不同步的设施或者优先级不同的设施之间的传输数据，比方键盘、鼠标等；

此外，buffer 个别是用在写入磁盘的；Cache 缓存区是位于 CPU 和主内存之间的容量较小但速度很快的存储器，Cache 保留着 CPU 刚用过的数据或循环应用的数据；Cache 缓存区的使用个别是在 I / O 的申请上

缓存区按性质分为两种，一种是输出缓冲区，另一种是输入缓冲区。

对于 C、C++ 程序来言，相似 cin、getchar 等输出函数读取数据时，并不会间接从键盘上读取，而是遵循着一个过程：cingetchar –> 输出缓冲区 –> 键盘，

咱们从键盘上输出的字符先存到缓冲区外面，cingetchar 等函数是从缓冲区外面读取输出；

那么绝对于输入来说，程序将要输入的后果并不会间接输入到屏幕当中区，而是先寄存到输入缓存区，而后利用 coutputchar 等函数将缓冲区中的内容输入到屏幕上。

cin 和 cout 实质上都是对缓冲区中的内容进行操作。

应用缓冲区机制的次要能够解决的问题，次要有:

• 缩小 CPU 对磁盘的读写次数: CPU 读取磁盘中的数据并不是间接读取磁盘，而是先将磁盘的内容读入到内存，也就是缓冲区，而后 CPU 对缓冲区进行读取，进而操作数据；计算机对缓冲区的操作工夫远远小于对磁盘的操作工夫，大大的放慢了运行速度
• 进步 CPU 的执行效率: 比如说应用打印机打印文档，打印的速度是绝对比较慢的，咱们操作 CPU 将要打印的内容输入到缓冲区中，而后 CPU 转手就能够做其余的操作，进而进步 CPU 的效率
• 合并读写: 比如说对于一个文件的数据，先读取后写入，循环执行 10 次，而后敞开文件，如果存在缓冲机制，那么就可能只有第一次读和最初一次写是实在操作，其余的操作都是在操作缓存

然而, 在缓存 I/O 机制中，DMA 形式能够将数据间接从磁盘读到页缓存中，或者将数据从页缓存间接写回到磁盘上，而不能间接在应用程序地址空间和磁盘之间进行数据传输。

这样，数据在传输过程中须要在应用程序地址空间（用户空间）和缓存（内核空间）之间进行屡次数据拷贝操作，这些数据拷贝操作所带来的 CPU 以及内存开销是十分大的。

在 Linux 中，缓冲区分为三大类：全缓冲、行缓冲、无缓冲，其中：

• 全缓冲；只有在缓冲区被填满之后才会进行 I / O 操作；最典型的全缓冲就是对磁盘文件的读写。
• 行缓冲；只有在输出或者是输入中遇到换行符的时候才会进行 I / O 操作；这忠容许咱们一次写一个字符，然而只有在写完一行之后才做 I / O 操作。一般来说，规范输出流 (stdin) 和规范输入流 (stdout) 是行缓冲。
• 无缓冲；规范 I / O 不缓存字符；其中体现最显著的就是规范谬误输入流(stderr)，这使得出错信息尽快的返回给用户。

2. 间接 IO(Direct I/O)

间接 IO(Direct I/O)是指应用程序间接拜访磁盘数据，而不通过内核缓冲区，也就是绕过内核缓冲区，本人治理 IO 缓存区，这样做的目标是缩小一次内核缓冲区到用户程序缓存的数据复制。

间接 IO 就是在应用层 Buffer 和磁盘之间间接建设通道。这样在读写数据的时候就可能缩小上下文切换次数，同时也可能缩小数据拷贝次数，从而提高效率。

引入内核缓冲区的目标在于进步磁盘文件的拜访性能，因为当过程须要读取磁盘文件时，如果文件内容曾经在内核缓冲区中，那么就不须要再次拜访磁盘。而当过程须要向文件写入数据是，实际上只是写到了内核缓冲区便通知过程曾经写胜利，而真正写入磁盘是通过肯定的策略进行延时的。

然而，对于一些较简单的利用，比方数据库服务器，他们为了充沛进步性能。心愿绕过内核缓冲区，由本人在用户态空间工夫并治理 IO 缓冲区，包含缓存机制和写提早机制等，以反对独特的查问机制，比方数据库能够依据加正当的策略来进步查问缓存命中率。另一方面，绕过内核缓冲区也能够缩小零碎内存的开销，因为内核缓冲区自身就在应用零碎内存。

3. 内存映射(Memory-Mapped,mmap)

内存映射 (Memory-Mapped I/O,mmap) 是指把物理内存映射到过程的地址空间之内，这些应用程序就能够间接应用输入输出的地址空间，从而进步读写的效率。

内存映射（Memory-mapped I/O）是将磁盘文件的数据映射到内存，用户通过批改内存就能批改磁盘文件。

Linux 提供了 mmap()函数，用来映射物理内存。在驱动程序中，应用程序以设施文件为对象，调用 mmap()函数，内核进行内存映射的筹备工作，生成 vm_area_struct 构造体，而后调用设施驱动程序中定义的 mmap 函数。

4. 零拷贝(Zero Copy)

零拷贝 (Zero Copy) 技术是指计算机执行操作时，CPU 不须要先将数据从某处内存复制到另一个特定区域，这种技术通常用于通过网络传输文件时节俭 CPU 周期和内存带宽。

在此之前，咱们须要晓得什么是拷贝？拷贝次要是指把数据从一块内存中复制到另外一块内存中。

零拷贝 (Zero Copy) 是一种 I / O 操作优化技术，次要是指计算机执行操作时，CPU 不须要先将数据从某处内存复制到另一个特定区域，通常用于通过网络传输文件时节俭 CPU 周期和内存带宽，还能够缩小上下文切换以及 CPU 的拷贝工夫。

然而须要留神的是，零拷贝技术理论实现并没有具体的规范，次要取决于操作系统如何实现和齐全依赖于操作系统是否反对？一般来说，操作系统反对，就能够零拷贝；否则就没有方法做到零拷贝。

一般来说，当咱们须要把一些本地磁盘的文件 (File) 中的数据发送到网络的时候，对于默认的规范 i / O 来说，Read 操作流程：磁盘 -> 内核缓冲区 -> 用户缓冲区 –> 应用程序内存 和 Write 操作流程：磁盘 <- 内核缓冲区 <- 用户缓冲区 <- 应用程序内存，整个过程中数据拷贝会有 6 次拷贝，3 次 Read 操作，3 次 Write 操作。

如果不必零拷贝，一般来说，次要采纳如下两种形式实现：

• 第一种实现形式：利用间接 I / O 实现：磁盘 -> 内核缓冲区 -> 应用程序内存 ->Socket 缓冲区 -> 网络，整个过程中数据拷贝会有 4 次拷贝，2 次 Read 操作，2 次 Write 操作，内存拷贝是 2 次。

• 第二种实现形式：利用内存映射文件 (mmnp) 实现：磁盘 -> 内核缓冲区 ->Socket 缓冲区 -> 网络，整个过程中数据拷贝会有 3 次拷贝，2 次 Read 操作，1 次 Write 操作，内存拷贝是 1 次。

如果应用零拷贝技术实现的话，磁盘 -> 内核缓冲区 -> 网络，整个过程中数据拷贝会有 2 次拷贝，1 次 Read 操作，1 次 Write 操作，内存拷贝是 0 次。

由此可见，零拷贝是从内存的角度来说，数据在内存中没有产生过数据拷贝，只在内存和 I / O 之间传输。

在 Linux 中，零碎提供了 sendfile 函数来实现零拷贝，次要模式：

 sendfile(int out_fd,int in_fd,off_t * offset,size_t count)

参数形容：

• out_fd：待写入内容的文件描述符，个别为 accept 的返回值
• in_fd：待读出内容的文件描述符，个别为 open 的返回值
• offset：指定从读入文件流的哪个地位开始读，如果为空，则应用读入文件流的默认地位，个别设置为 NULL
• count：两文件描述符之间的字节数，个别给 struct stat 构造体的一个变量，在 struct stat 中能够设置文件描述符属性

⚠️[特地留神]：

in_fd 规定指向实在的文件，不能是 socket 等管道文件描述符，个别使 open 返回值，而 out_fd 则是 socket 描述符

在 Java 中，FileChannel 提供 transferTo（和 transferFrom）办法来实现 sendFile 性能。

(四). 被动 (Reacror) 与被动(Proactor)I/ O 模型

被动与被动 I / O 模型是指网络 I / O 模型中的基于 Reacror 模式与 Proactor 模式等两种设计模式设计的 I / O 模型，算是所有网络 I / O 模型的形象模型。

除了上述提到的网络 I / O 模型，还有基于 Reacror 模式与 Proactor 模式等两种设计模式设计的 I / O 模型，是网络框架的根本设计模型。

不论是操作系统的网络 I / O 模型的设计，还是下层框架中的网络 I / O 模型的设计，都是基于这两种设计模式来设计的。其中：

1.Reacror 模式：

Reacror 模式是被动模式，次要是指应用程序一直轮询，拜访操作系统，或者网络框架，网络 I / O 模型是否就绪。

在 Linux 零碎中，其 select，poll 和 epoll 等网络 I / O 模型都是 Reacror 模式下的产生物。须要在应用程序外面一只有一个循环来轮询。其中，Java 中的 NIO 模型也是属于这种模式。

在 Reacror 模式下，理论的 网络 I / O 申请操作都是在应用程序下执行的。

2.Proactor 模式:

Proactor 模式是被动模式，次要是指应用程序网络 I / O 操作申请全副托管和交付给操作系统或者网络框架来实现。

在 Proactor 模式下，理论的 网络 I / O 申请操作都是在应用程序下执行，之后再回调到应用程序。

(五). 服务器编程 I / O 模型

服务器编程 I / O 模型是指一个服务器会有 1 +N+ M 个线程，次要有 1 个监听线程，N 个 I / O 线程，M 个 Worker 线程，因而也称为 1 +N+ M 服务器编程模型。

在 1 +N+ M 服务器编程模型中，监听线程 -> 对应每一个客户端 socket 建设和连贯，I/ O 线程 -> 对应 N 的个数通常是以 CPU 核数作为参考，而 Worker 线程 >M 的个数依据理论业务场景的数据下层决定。其中：

• 监听线程：次要负责 Accept 事件的注册和解决。和每一个新进来的客户端建设 socket 连贯，而后把 socket 连贯转接交给 I / O 线程，实现完结后持续监听新的客户端申请。
• I/ O 线程：次要负责每个 socket 连贯下面 read/write 事件的注册和理论的 socket 的读写。负责把读到的申请放入 Requset 队列，最初托管交给 Worker 线程解决。
• Worker 线程：次要是纯正的业务线程，没有 socket 连贯上的 read(读)/write(写)操作。Worker 线程解决完申请最初写入响应 Response 队列，最终交给 I / O 线程返回客户端。

实际上，在 linux 零碎中 epoll 和 Java 中的 NIO 模型，以及基于 Netty 的开发的网络框架，都是依照 1 +N+ M 服务器编程模型来做的。

写在最初

I/ O 模型是为解决各种问题而提出的，次要波及有线程(Thread)，阻塞(Blocking)，非阻塞(Non-Blocking)，同步(Synchronous) 和异步(Asynchronous) 等相干的概念。

依照肯定意义上说，I/ O 模型能够分为阻塞 I /O(Blocking IO，BIO)，非阻塞 I /O(Non-Blocking IO，NIO)两大类。

在 Linux 零碎中，其中：

• 依据 UNIX 网络编程对 I / O 模型的分类来说，网路 I /O 模型次要分为同步阻塞 IO(Blocking I/O,BIO)，同步非阻塞 IO(Non-Blocking I/O,NIO)，IO 多路复用 (I/O Multiplexing)，异步 IO(Asynchronous I/O,AIO) 以及信号驱动式 I /O(Signal-Driven I/O)等 5 种模型。
• 依照文件操作 IO 来说，次要分为缓冲 IO(Buffered I/O)，间接 IO(Direct I/O)，内存映射 (Memory-Mapped,mmap)，零拷贝(Zero Copy) 等 4 种模型。

其中，在文件操作 I / O 中，咱们须要区别对待拷贝和映射：
拷贝次要是指把数据从一块内存中复制到另外一块内存中，而映射只是持有数据的一份援用(或者叫地址)，数据自身只有一份。

除此之外，网络 I / O 模型，还有基于 Reacror 模式与 Proactor 模式等两种设计模式设计的 I / O 模型，是网络框架的根本设计模型。

以及，一个服务器会有 1 +N+ M 个线程，次要有 1 个监听线程，N 个 I / O 线程，M 个 Worker 线程，因而也称为 1 +N+ M 服务器编程模型。

综上所述，只有正确和分明地晓得这个根底领导，能力加深咱们对 Java 畛域中的多线程模型的意识，能力更好地领导咱们把握并发编程。

版权申明：本文为博主原创文章，遵循相干版权协定，如若转载或者分享请附上原文出处链接和链接起源。