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

写在结尾

作为一名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畛域中的多线程模型的意识，能力更好地领导咱们把握并发编程。

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