【Java基础】从Java语言层面理解BIO，NIO，AIO(二)

ゝ一纸荒年。 2023-02-18 05:24 6阅读 0赞

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]

### 文章目录 ###

*  零.从网络层面理解BIO，NIO，AIO
 *  一.相关概念
 *   *  1.什么是socket?
     *  2.IP地址（IP Address）
     *  3.端口（Port）
     *  4.协议（Protocol）
     *   *  4.1.协议简介
         *  4.2.套接字分类(数据传输方式)
         *   *  4.2.1.流式套接字(SOCK\_STREAM)
             *   *  1.流式套接字简介
                 *  2.流式套接字系统调用函数图
             *  4.2.2.数据报套接字(SOCK\_DGRAM)
             *   *  1.数据报套接字简介
                 *  2.数据报套接字系统调用函数图
             *  4.2.3原始套接字(SOCK\_RAW)
     *  5.物理内存与虚拟内存
     *  6.ROM(硬盘)与RAM(内存)
     *  7.单工、半双工和全双工
     *  8.构造函数、析构函数
 *  二.Java中的BIO
 *   *  1.核心概念
     *  2.BIO实现简易单线程服务器
     *  3.BIO通过线程池处理并发
 *  三.Java中的NIO
 *   *  0.为什么要使用NIO?
     *  1.核心概念
     *  2.三大核心
     *   *  2.1.Buffer(缓存区)
         *   *  2.1.1.概念
             *  2.1.2.Buffer的常用方法
             *  2.1.3.如何读写Buffer的数据
             *  2.1.4.Buffer的4个重要属性
             *  2.1.5.直接缓冲区与非直接缓存区
             *   *  1.非接缓存区
                 *  2.直接缓存区
             *  2.1.6.Buffer的代码示例
         *  2.2.Channel(通道)
         *   *  2.2.1.概念
             *  2.2.2.Channel的常用方法
             *  2.2.2.Channel的代码示例
             *   *  1.FileChannel的使用(常用)
                 *   *  1.1.概念
                     *  1.2.通道获取
                     *  1.3.分散读取(Scatter Reads)和聚集写入(Gather Writes)
                     *  1.4.读取数据
                     *  1.5.写入数据
                     *  1.6.文件锁
                     *  1.7.通道间数据传输
                     *  1.8.截取文件
                     *  1.9.映射文件到直接缓冲区
                     *  1.10.小结
                 *  2.SocketChannel的使用
                 *   *  2.1.NIO客户端-版本1
                     *  2.2.NIO服务端-版本1
                     *  2.3.NIO服务端-版本2
                 *  3.真实NIO中如何解决这些问题
                 *  4.关于select/poll/epoll和直接在应用层做轮询的区别
         *  2.3.Selector(选择器)
         *   *  2.3.1.概念
             *  2.3.2.Selector常用方法
             *  2.3.3.使用Selector的步骤
             *  2.3.4.SelectionKey的概念
             *  2.3.5.SelectionKey的常用方法
             *  2.3.6.Selector的代码示例
             *   *  1.NIO客户端-版本2
                 *  2.NIO服务端-版本3
     *  4.BIO与NIO的区别
 *  四.Java中的AIO
 *   *  1.核心概念
     *   *  2.AIO的代码示例
         *  2.1.AsynchronousFileChannel
         *   *   *  通道获取
                 *  读取数据
                 *  写入数据
         *  2.2.异步网络IO的代码示例
 *  五.适用场景

# 零.从网络层面理解BIO，NIO，AIO #

[【Java基础】从网络层面理解BIO，NIO，AIO(一)][Java_BIO_NIO_AIO]

# 一.相关概念 #

## 1.什么是socket? ##

在计算机通信领域，socket 被称为 “`套接字`”，是一个抽象层。它是**计算机之间进行通信的一种约定或一种方式**。通过这种约定`一台计算机可以接收来自其他计算机的数据 或 向其他计算机发送数据`。`网络socket是网络协议。IP地址与端口的组合`。

*  在一个小区(`计算机`)里面有很多住户(`应用程序`)，小区用`门牌号(端口)`区分每一户人家，需要寄快递到小明家的时候，只需要根据`小区地址+门牌号` 就可以准确定位到小明家。小明家的入口就可以用`小区地址+门牌号进行唯一表示`，同理，程序也可以用`IP+端口号进行唯一标识`。那么这个程序的入口就被称作`Socket`。
    
     *  通信的`2端(`客户端、服务端)都有Socket。网络通信其实就是`Socket间的通信`，`将数据在2个Socket间通过IO传输`。

## 2.IP地址（IP Address） ##

*  计算机分布在世界各地，要想和它们通信，必须要知道确切的位置。`IP 地址`是最常用的确定计算机位置的方式
    
     *  例如，114.114.114.114 是`国内第一个、全球第三个开放的 DNS 服务地址`，127.0.0.1 是本机地址。
 *  其实 **，我们的计算机并不知道 IP 地址对应的地理位置，当要通信时，只是将 IP 地址封装到要发送的数据包中，交给`路由器`去处理。路由器有非常智能和高效的算法，很快就会找到目标计算机，并将`数据包`传递给它，完成一次`单向通信`**。
 *  目前大部分软件使用`IPv4`地址，但 IPv6 也正在被人们接受，尤其是在`校园网`中，已经大量使用。
    
    > ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]

## 3.端口（Port） ##

*  有了 IP 地址，虽然可以找到目标计算机，但仍然不能进行通信。一台计算机会同时启动多种应用程序，例如Web程序、FTP程序（文件传输服务）、SMTP程序（邮箱服务）等，**仅有 IP 地址，计算机虽然可以正确接收到数据包，但是却不知道要将数据包交给哪个网络程序来处理，所以通信失败。**
    
     *  因此计算机需要为每个程序分配一个唯一的`端口号（Port Number）` 来对不同的程序进行`区分`。
        
         *  例如：Web服务的端口号是 80，FTP 服务的端口号是 21，SMTP 服务的端口号是 25。
         *  `端口（Port）`是一个 `虚拟的、逻辑`上的概 念。可以将端口理解为一道门，数据通过这道门流入流出，每道门有不同的编号，就是端口号。如下图所示：  
            ![在这里插入图片描述][20210615175500954.png]

## 4.协议（Protocol） ##

### 4.1.协议简介 ###

*  `协议（Protocol）`就是`网络数据传输的约定`，**通信的双方必须都遵守才能正常`收发数据`**。协议有很多种，例如`TCP、UDP、IP`等，**通信的双方必须使用`同一协议`才能通信**。协议是一种规范，由`计算机组织`制定，规定了很多细节，例如，**如何建立连接，如何相互识别**等。
    
     *  所谓协议族`（Protocol Family）`，就是 **`一组协议（多个协议）的统称`**。最常用的是 `TCP/IP 协议族`，**它包含了 `TCP、IP、UDP、Telnet、FTP、SFTP、SMTP` 等上百个`互为关联`的协议。由于 TCP、IP 是两种常用的底层协议，所以把它们统称为 `TCP/IP 协议族`**。

### 4.2.套接字分类(数据传输方式) ###

计算机之间有很多数据传输方式，各有优缺点，常用的2两种：`sock_stream 和 sock_dgram`。

#### 4.2.1.流式套接字(SOCK\_STREAM) ####

##### 1.流式套接字简介 #####

表示`面向连接、可靠的数据传输方式`。能将数据`无差错、无重复送，并按顺序收发`。原因在于使用了`传输控制协议，即TCP(The Transmission Control Protocol)`。

> 面向连接：指的是应用进程在向另一个应用进程发送数据前，需要先进行握手，即它们必须先相互发送预备报文段，用来建立确保数据传输的参数。

1.  `SOCK_STREAM 通过 "字节流" 的方式收发数据`，可以保证数据准确无误地到达另一台计算机，如果损坏或丢失，可以重新发送，但效率相对较慢（因为要确保数据的正确性，否则网页不能正常解析）。常见的 `http 协议`就使用 SOCK\_STREAM 传输数据
2.  数据在`客户端是顺序发送的`，并且`到达服务端的顺序是一致`的。如：客户端先发1，再发2，在服务器端的接收顺序是先收到1，再收到2

##### 2.流式套接字系统调用函数图 #####

> 为了支持开发基于网络通信的应用程序，所有操作系统提供了基于TCP或者UDP的API函数(系统调用)

基于传输层协议TCP  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]\- [Linux常用系统调用][Linux]

#### 4.2.2.数据报套接字(SOCK\_DGRAM) ####

##### 1.数据报套接字简介 #####

表示`无连接 且 不可靠的数据传输方式`。该方式`并不能保证数据传输的可靠性,数据有可能在传输过程中丢失或出现数据重复，且无法保证顺序地接收到数据`。SOCK\_DGRAM 使用`UDP( User DatagramProtocol)协议`进行数据的传输。

1.  `SOCK_DGRAM 通过 "数据包" 方式收发数据`，数据的收发无顺序，并且接收到的数据还可能出现的数据损坏、丢失等情况。
2.  `SOCK_DGRAM 效率比 SOCK_STREAM高`。原因是SOCK\_DGRAM 只做少量的数据校验，如果数据在传输过程中丢失、损坏，无法重传。
    
     *  `QQ 视频聊天和语音聊天`就使用 SOCK\_DGRAM 传输数据，因为首先要**保证通信的效率，尽量减小延迟，而数据的正确性是次要的，即使丢失很小的一部分数据，视频和音频也可以正常解析，最多出现噪点或杂音，不会对通信质量有实质的影响。**
     *  但注意!!!：SOCK\_DGRAM 没有想象中的糟糕，不会频繁的丢失数据，数据错误只是小概率事件。

既然这样那为什么还要使用SOCK\_DGRAM呢？

*  `因为现在每个使用udp的程序都有自己的对数据进行确认的协议`。**如： TFTP 协议规定了对于每一个发送出去的数据包,远程在接受到之后都要回送一个数据包告诉本地程序: “我已经拿到了!(一 ”个 “ACK” 包) 。如果数据包发的送者在 5 秒内没有的得到回应,它就会重新发送这个数据包直到数据包接受者回送了 “ACK” 信号。**

##### 2.数据报套接字系统调用函数图 #####

> 为了支持开发基于网络通信的应用程序，所有操作系统提供了基于TCP或者UDP的API函数(系统调用)

基于传输层协议UDP  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]

*  [Linux常用系统调用][Linux]

#### 4.2.3原始套接字(SOCK\_RAW) ####

与流套接字和数据报套接字的区别在于：

*  原始套接字`可以读写内核没有处理的IP数据包`，而流套接字只能读取TCP协议的数据，数据报套接字只能读取UDP协议的数据。因此，**如果要访问其他协议发送的数据必须使用原始套接字**
    
     *  功能强大,但是没有上面介绍的两种套接字使用方便,一般的程序也涉及不到原始套接字,本人的了解也较少

**综上所述：`IP地址和端口`能够在广袤的互联网中定位到要通信的程序，`协议和数据传输方式规定了如何传输数据`，有了这些，两台计算机就可以通信了。**

--------------------

[socket是什么？套接字是什么？][socket]

## 5.物理内存与虚拟内存 ##

*  **物理内存（Physical memory）** 是相对于虚拟内存而言的。`物理内存指通过物理内存条而获得的内存空间`，常见的物理内存规格有`256M、512M、1G、2G`等，现如今随着计算机硬件的发展，已经出现4G、8G、16G甚至更高容量的内存规格。**也就是我们常说的`运行内存`**

> 最简单的查看方法: 选择`任务管理器`’,再单击‘`性能`  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]

*  **虚拟内存（Virtual Memory）**：电脑中所运行的程序均需经由内存执行，若执行的程序占用内存很大或很多，则会导致内存消耗殆尽。为解决该问题，Windows中运用了**虚拟内存技术**，即`拿出一部分硬盘空间来充当内存使用，这部分空间即称为“虚拟内存”。当内存耗尽时，电脑就会自动调用硬盘来充当内存，以缓解内存的紧张`。 **虚拟内存在硬盘上的`存在形式`就是`PAGEFILE.SYS`这个页面文件**
    
     *  举一个例子来说：如果电脑只有128MB物理内存的话，当读取一个容量为200MB的文件时，就必须要用到比较大的虚拟内存，文件被内存读取之后就会先储存到虚拟内存，等待内存把文件全部储存到虚拟内存之后，跟着就会把虚拟内里储存的文件释放到原来的安装目录里了。
     *  虚拟内存是`Windows 为作为内存使用的一部分硬盘空间`。虚拟内存在硬盘上其实就是`一个硕大无比的文件`，文件名是`PageFile.Sys`，通常状态下是看不到的。必须`关闭资源管理器对系统文件的保护功能`才能看到这个文件。**虚拟内存有时候也被称为是`“页面文件”`就是从这个文件的文件名中来的**。
     *  目前，大多数操作系统都使用了虚拟内存，如`Windows的“虚拟内存”；Linux的“交换空间”`等

**虚拟内存原理取自百度百科**

*  它将计算机的物理内存和硬盘上的临时空间组合。当`物流`运行速率缓慢时，它便将数据从`物流内存`移动到称为`“分页文件”`的空间中。`将数据移入分页文件可释放物理内存`，以便完成工作。 一般而言，计算机的物理内存`容量越大，程序运行得越快。`若计算机的速率由于`物理内存可用空间匮乏而减缓`，则可`尝试通过增加虚拟内存来进行补偿`。但是，**计算机从物理内存读取数据的速率要比从硬盘读取数据的速率快，因而`扩增物理内存容量（可加内存条）`是最佳选择**。

## 6.ROM(硬盘)与RAM(内存) ##

**ROM和RAM都是一种`存储技术`，只是两者原理不同**

*  **ROM和RAM指的都是半导体存储器**。本来的含义是：
 *  **ROM(Read Only Memory)是只读内存**的缩写，也就是说这种存储器`只能读，不能写`。
 *  **RAM(Random Access Memory)是随机存储内存的**缩写。这个词的由来是因为早期的计算机曾经使用`磁鼓`作为内存，而`磁鼓和磁带都是典型的顺序读写设备`。RAM则可以`随机读写`。

**ROM与RAM的主要区别是什么?**

*  通俗的说，比如在电脑中，大家都知道有`内存`和`硬盘`之说，其实 **`内存`就是一种RAM技术，而ROM则类似于`硬盘`技术**，`两者都是存储器，只是RAM的速度要远远高于ROM的速度`，
 *  在电脑日常操作中，很多程序都将临时运行的程序命令，都存放在 **`内存`** 中，**一旦关机或者停电，`内存`里原本临时存储的程序信息将全部被清空，也就是`内存只能临时存储东西，不能长久保存`**，而 **`ROM`则可以存储，即使掉电后也可以找到之前存储的文件，这也就是`硬盘`了。**

**手机中的RAM和ROM**

*  在手机中，**RAM属手机内部存储器**，指的是`手机内存`，属于随机存储，速度高于ROM，手机断电后RAM数据将被清空，比如手机运行着QQ与其它软件，重启手机后，软件就没有处于登录状态。**通常一部手机除了手机处理器外，如果内存越大手机配置越好**
    
    > 手机中的RAM对应的是电脑的内存，负责程序的运行以及数据交换
 *  而**ROM则属于外部存储**，比如`手机内存SD卡就属于ROM范畴`，也可以简单的理解成`手机硬盘`。用来存储手机系统文件、图片、电影等等，不会随着掉电而丢失数据，ROM越大存储的数据就越多。
    
    > 手机中的RAMROM对应的是电脑中的硬盘，是一块存储空间，可以存储各种各样的文件，包括视频，照片，音乐，软件等

## 7.单工、半双工和全双工 ##

**单工、半双工和全双工是计算机网络中的三种通信信道**

1.  **单工数据传输**：只支持数据在`一个方向`上传输；在同一时间只有一方能接受或发送信息，不能实现双向通信，举例：监视器、电视，广播。
    
    > 单工通信只有`一根数据线`
2.  **半双工数据传输**：允许数据在`两个方向`上传输,但是,在某一时刻,只允许数据在一个方向上传输,它实际上是一种\`切换方向的单工通信；在同一时间只可以有一方接受或发送信息，可以实现双向通信。举例：对讲机。
    
    > 半双工通信也只有`一根数据线`，它也单工的区别是这根数据线既可作发送又可作发接收，虽然数据可在两个方向上传送，但通信双方不能同时收发数据。
3.  **全双工数据传输**：允许数据`同时在两个方向`上传输,因此,全双工通信是`两个单工通信方式的结合` , 它要求**发送设备和接收设备都有独立的接收和发送能力**；在同一时间可以同时接受和发送信息，实现双向通信，举例：电话通信。
    
    > 数据的发送和接收用`两根不同的数据线`，通信双方在同一时刻都能进行发送和接收，这一工作方式称为全双工通信。在这种方式下，通信双方都有发送器和接收器，发送和接收可同时进行，没有时间延迟。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]

1.  **网卡的全双工**（Full Duplex）：是指网卡在发送数据的同时也能够接收数据,两者同步进行,这好像我们平时打电话一样,说话的同时也能够听到对方的声音.目前的网卡一般都支持全双工.

## 8.构造函数、析构函数 ##

*  构造函数的功能：是在创建对象时，使用给定的值来将对象初始化。
 *  析构函数的功能：是用来释放一个对象的。在对象删除前，用它来做一些清理工作，

# 二.Java中的BIO #

## 1.核心概念 ##

**JAVA-BIO (Blocking-I/O)，即:`同步阻塞I/O`**

*  `BIO 就是传统的 java.io 包`，**Java 1.4以前**的 **阻塞io模型**，基于`流模型`实现的，交互的方式是`同步、阻塞`的，`读写动作完成之前，线程会一直阻塞在那里`。
 *  **服务器实现模式**：**一个连接一个线程** ,`服务器端为每一个客户端的连接请求都需要启动一个线程进行处理。可以通过线程池机制改善。`
    
    > **缺点**
    > 
    > 1.  每创建一个线程。就会为线程分配一定的`工作内存`,而操作系统本身也对`线程的总数`有 一定的限制。如果客户端的请求过多，服务端程序可能会因为`并发量过大`而拒绝客户端的请求，甚至服务器可能因此`瘫痪`。
    > 2.  使用流来读取数据，流是阻塞的，当没有可读／可写数据时，线程等待，会造成资源的浪费；
 *  经典的烧开水例子: 假设一个烧开水的场景，有一排水壶在烧开水，**BIO的工作模式**就是， 叫`一个线程停留在一个水壶那，直到这个水壶烧开，才去处理下一个水壶`。但是实际上线程在等待水壶烧开的时间段什么都没有做。
    
    > 老王`一直看着着这个水壶，直到这个水壶烧开，才去处理下一个水壶`。线程在`等待水壶烧开`的时间段什么都没有做
    
    > ps， Java.net提供的API，如Socket，ServerSocket，HttpURLConnection也归与同步阻塞IO类库，因为网络通信同样是IO行为。因此IO不仅仅是文件的操作，网络编程中，比如Socket通信也是典型的IO操作。
    > 
    >  *  在`Java 1.4之前`，建立网络连接采用`BIO模式`，需要先在服务端启动一个`ServerSocket`，然后在`客户端启动Sokcet`来对服务端进行通讯，**默认情况下服务端需要对每个请求建立一个线程等待请求**，而客户端发送请求后，先询问服务端是否有线程对应，如果没有则会一直等待或者遭到拒绝请求，如果有的话，客户端会等待请求结束后才继续执行。

## 2.BIO实现简易单线程服务器 ##

*  因为在`单线程环境`下可以很好地对比出BIO和NIO的一个区别，当然也会演示在实际环境中BIO的所谓`一个请求对应一个线程的场景`。

服务端，实例化了一个`SocketServer`并绑定了`8088端口`。之后调用`accept方法`来接收连接请求，并且调用`read方法`来`接收客户端发送的数据`。最后将接收到的数据`打印`。

/** * 服务端 */
    public class Server { 
        public static void main(String[] args) { 
            byte[] buffer = new byte[1024];
            try { 
            	//设置服务端绑定的端口好
                ServerSocket serverSocket = new ServerSocket(8088);
                System.out.println(Thread.currentThread().getName()+"：服务器已启动并监听8088端口");
                //循环监听客户端请求
                while (true) { 
                    System.out.println(Thread.currentThread().getName()+"：服务器正在等待连接...");
                    Socket socket = serverSocket.accept();// 阻塞1：等待连接时阻塞
                    System.out.println(Thread.currentThread().getName()+"：服务器已接收到连接请求...");
    
                    System.out.println(Thread.currentThread().getName()+"：服务器正在等待数据...");
                    socket.getInputStream().read(buffer); //阻塞2：等待数据时阻塞
                    System.out.println(Thread.currentThread().getName()+"：服务器已经接收到数据");
    
                    String content = new String(buffer);
                    System.out.println(Thread.currentThread().getName()+"：接收到的数据:" + content+"\n");
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

客户端当客户端连接服务器后，不立即发送数据，而是等待控制台手动输入数据后，再发送给服务端

/** * 升级版客户端,允许客户端通过控制台输入数据然后请求到服务端 */
    public class Consumer { 
        public static void main(String[] args) { 
            try { 
            	//连接服务端
                Socket socket = new Socket("127.0.0.1",8088);
    
                //接收控制台输入
                System.out.println("请输入数据:");
                Scanner sc = new Scanner(System.in);
                String message  = sc.next();
    
                //发送数据到服务端
                socket.getOutputStream().write(message.getBytes());
                socket.close();
                sc.close();
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    }

启动服务器，但客户端还没有向服务器发起连接时,服务端会`阻塞accept()处`等待客户端请求

![服务端][20200226143939537.png]

当服务端启动，`客户端1`**第1个**连接服务端，但没有发送数据时  
![客户端][20200226115422900.png]  
服务端会`阻塞read()处`等待读取客户端请求数据  
![服务端][20200226144158516.png]

`客户端2`**第2个**连接服务端，且发送数据到客户端  
![客户端2][2]  
`客户端2`**第3个**连接服务端，且发送数据到客户端  
![客户端3][3]  
此时虽然`客户2和客户端3`已经提交请求并主动断开连接,但服务端仍然阻塞在`read()`方法处，等待读取`客户端1`提交的数据  
![服务端][20200226144401312.png]

`客户端1`提交请求数据后`read()阻塞解除`, 依次处理`客户端2,客户端3`请求  
![客户端][20200226144628528.png]

可以看出,  
![服务端][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]

`服务端完成一次客户端请求后,会阻塞在`**accept()处**`,等待下一次客户端的请求`  
![服务端][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]  
**结论:**

*  服务器端在启动后，首先需要`等待客户端的连接请求`（第一次阻塞在`accept()`），如果没有客户端连接，服务端将一直`阻塞等待`，然后当客户端连接后，服务器会等待客户端发送数据（第二次阻塞在`read()`），**如果客户端没有发送数据，那么服务端将会一直阻塞等待客户端发送数据。**
 *  服务端从启动到收到客户端数据的这个过程，将会有`2次阻塞`的过程。这就是`BIO的非常重要的一个特点，BIO会产生两次阻塞，第一次在等待连接时阻塞，第二次在等待数据时阻塞。`

**在单线程条件下BIO的弊端**

*  上文服务器是`以单线程运行的`，当服务器接收到一个连接后，并且`没有接收到客户端发送的数据时`，是会阻塞在`read()方法`中的，那么此时`如果再来一个客户端的请求，服务端是无法进行响应的。`换言之，在**不考虑多线程的情况下，BIO是无法处理多个客户端请求的。**

## 3.BIO通过线程池处理并发 ##

*  `上文单线程版的BIO并不能处理多个客户端的请求`，我们 **`只需要在每一个连接请求到来时，创建一个线程去执行这个连接请求`**，就可以在BIO中处理多个客户端请求了，这也就是为什么BIO的其中一条概念是**服务器实现模式为一个连接一个线程，即`客户端有连接请求时服务器端就需要启动一个线程进行处理`。**

多线程BIO服务器简易实现(客户端实现同上)

public class Server { 
        //声明线程池 核心线程：内核数，最大线程数:内核数*2,非核心线程空闲时间,阻塞队列为100
        private static ThreadPoolExecutor executor = new ThreadPoolExecutor(Runtime.getRuntime().availableProcessors(), Runtime.getRuntime().availableProcessors() * 2, 60, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<>(100));
    
        public static void main(String[] args) { 
            try { 
                //服务端绑定8080端口
                ServerSocket serverSocket = new ServerSocket(8088);
                System.out.println("服务器已启动并监听8088端口");
                while (true) { 
                    System.out.println();
                    System.out.println("服务器正在等待连接...");
                    Socket socket = serverSocket.accept();//每次请求到来,都开启一个线程单独处理,防止因当前请求未处理完成,导致其他请求进行等待
    
                    executor.execute(new Runnable() { 
                        @Override
                        public void run() { 
                            System.out.println("服务器已接收到连接请求...");
                            System.out.println("服务器正在等待数据...");
                            byte[] readBytes = new byte[1024];
                            try { 
                                socket.getInputStream().read(readBytes);
                            } catch (IOException e) { 
                                e.printStackTrace();
                            }
                            System.out.println("服务器已经接收到数据");
                            System.out.println();
                            String content = new String(readBytes);
                            System.out.println("接收到的数据:" + content);
                        }
                    });
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
            executor.shutdown();
        }
    }

**因为一个请求就要启动一个线程，所以开销是比较大的，启动和销毁线程开销很大，而且每个线程都要占用内存，所以可以引入"`线程池`"，可以在一定程度上减少线程创建和销毁的开销。**

*  **由线程池维护着`N 个线程`和一个`消息队列`；当有请求时，服务端将`Socket 作为参数`传递到一个`线程任务中进行处`理；通过对线程池`最大线程数`和`消息队列大小`进行控制，所以就算访问量高于服务端的承载能力，也不会因为服务端的资源耗尽而导致宕机；**
 *  这种方式在 **`请求量不高的时候，效率还是不错的`**，而且也不需要考虑限流的问题（控制线程池的最大线程数量）。

**运行结果**

*  现在有`3个客户端`请求服务端，但没有发送数据,服务端每次接收一个socket请求，都会通过`线程池`开启一个新的线程处理请求数据。  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]
 *  线程0、1、2接收到数据  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]

**多线程BIO服务器的弊端**

*  `多线程BIO服务器`虽然解决了`单线程BIO无法处理并发的弱点`: 但是也带来一个问题：如果有`大量的请求`连接到我们的服务器上，但是却不发送消息，那么我们的服务器也会为这些不发送消息的请求`创建一个单独的线程`，那么如果连接数少还好，`连接数一多就会对服务端造成极大的压力`。所以如果这种`不活跃的线程比较多`，我们应该采取单线程的一个解决方案，但是单线程又无法处理并发，这就陷入了一种很矛盾的状态，于是就有了**NIO**。

# 三.Java中的NIO #

## 0.为什么要使用NIO? ##

先来看看`单线程模式下BIO服务器的代码`，其实NIO需要解决的最根本的问题就是 `"存在于BIO中的2次阻塞"`，**分别是`等待连接时的阻塞`和`等待数据时的阻塞`。** 查看BIO的Java代码  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 10]

我们需要再老调重谈的一点是，`如果单线程服务器在等待数据时阻塞，那么第2个连接请求到来时，服务器是无法响应的。` **如果是多线程服务器，那么又会有为`大量空闲请求产生新线程`从而造成`线程占用系统资源`，`线程浪费`的情况。**

那么我们的问题就转移到，**如何让`单线程服务器在等待客户端数据到来时，依旧可以接收新的客户端连接请求`。**

## 1.核心概念 ##

**NIO(New-I/O, Non-BlockingI/O），即`同步非阻塞IO`** : **Java1.4以后**的**非阻塞IO模型**

*  `Java 1.4`引入的`java.nio`包，提供了`Channel(管道)、Selector(选择器)、Buffer(缓冲区)`等新的抽象，可以构建`多路复用的`、`同步非阻塞` IO 程序，`同时提供了更接近操作系统底层`**高性能**的数据操作方式，**`同时支持阻塞与非阻塞模式`**
    
     *  由于这套API是Java新提供的I/O API，因此，也叫`New I/O`，这就是`包名nio`的由来。
     *  在理解NIO的时，需要区分是`New I/O`还是`非阻塞IO`（**New I/O**是`Java的包`，NIO是`非阻塞IO概念`）。
 *  **服务器实现模式**：`客户端的连接请求都会注册到多路复用器上,用同一个线程接收所有连接请求。`
 *  **实现原理**
 *  > ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 11]
    > 
    > 1.  客户端与服务端通过`Channel`通信；
    > 2.  NIO在`Channel`上读写；
    > 3.  Channel被注册到`Selector多路复用器`上。Selector通过一个线程`轮询这些Channel`，找出`已经就绪的Channel`。

**那么什么叫做*同步非阻塞*？**

*  拿烧开水来说，NIO是`一个线程不断的`轮询`每个水壶的状态，看看是否有水壶的状态发生了改变`，如果某个水壶烧开了，可以先处理那个水壶，然后继续处理别的事情，继续隔一段时间又看看每个水壶的状态。
    
    > 还拿烧开水来说，NIO的做法是`老王一边玩着手机，每隔一段时间就看一看每个水壶的状态`，看看是否有水壶的状态发生了改变，如果某个水壶烧开了，可以先处理那个水壶，然后继续玩手机，继续隔一段时间又看看每个水壶的状态。
 *  NIO本身是基于`事件驱动思想`来完成的，主要解决的是`BIO的高并发问题`：在使用同步阻塞I/O的网络会**将每一个客户端请求分配给一个线程来单独处理**。这样做虽然可以达到我们的要求，**但并发大的时候会对服务端造成极大的压力**
    
     *  NIO基于`Reactor`模式，`当socket有流可读或可写入socket时，操作系统会相应的通知应用程序进行处理，程序再将流读取到缓冲区或写入操作系统`。 也就是说，这个时候，已经不是一个连接就要对应一个处理线程了，而是 **`一个有效的请求，对应一个线程`**，当连接没有数据时，是没有工作线程来处理的。

## 2.三大核心 ##

*  **通道(Channel)**：**负责`连接`**
 *  **缓冲区(Buffer)**：**负责数据的存取**
 *  **选择器(Select)**：**是SelectableChannel的多路复用器。用于监控SelectableChannel的IO状况。**
    
     *  **NIO和IO之间一个最大区别：IO是面向流的，NIO是`面向缓冲区的`，可以将数据读取到一个缓冲区，稍后进行处理。**

### 2.1.Buffer(缓存区) ###

#### 2.1.1.概念 ####

**Buffer 缓存区；高效的数据容器，可以理解成是一块`可写可读内存空间`，`数据可以从 Channel 流进 Buffer ，也可以从 Buffer 流进 Channel`**

*  NIO的数据操作都是在`缓存区`中进行的，`Buffer的本质通常是一个字节数组或者其他类型的数组`，NIO提供了`不同的Java数据类型的Buffer`，`常见类型`有:
    
     *  `ByteBuffer(最为常用)`
     *  CharBuffer
     *  ShortBuffer
     *  IntBuffer
     *  LongBuffer
     *  FloutBuffer
     *  DoubleBuffer等

#### 2.1.2.Buffer的常用方法 ####

**实例化Buffer**

*  **allocate(int capacity)** 从堆空间中分配一个容量大小为`capacity`的byte数组作为缓冲区的byte数据存储器
 *  **allocateDirect(int capacity)** 是`不使用JVM堆栈而是通过操作系统来创建内存块用作缓冲区`，它与当前操作系统能够更好的耦合，因此能进一步提高I/O操作速度。但是分配`直接缓冲区`的系统开销很大，因此只有在缓冲区较大并长期存在，或者需要经常重用时，才使用这种缓冲区
 *  **wrap(byte\[\] array)** 这个缓冲区的数据会存放在byte数组中，bytes数组或buff缓冲区任何一方中数据的改动都会影响另一方。其实ByteBuffer底层本来就有一个bytes数组负责来保存buffer缓冲区中的数据，通过allocate方法系统会帮你构造一个byte数组
 *  **wrap(byte\[\] array, int offset, int length)** ：在上一个方法的基础上可以指定偏移量和长度，这个`offset`也就是包装后byteBuffer的`position`，而length呢就是limit-position的大小，从而我们可以得到limit的位置为`length+position(offset)`

**读取数据**

*  **get()** ：从缓冲区读取单个字节
    
    > 相对读，从position位置读取一个byte，并将position+1，为下次读写作准备
 *  **get(int index)**：读取缓冲区指定索引位置的字节(不会移动 position)
    
    > 绝对读，读取byteBuffer底层的bytes中下标为index的byte，不改变position
 *  **get(byte\[\] dst)**：批量读取缓冲区多个字节到 dst 中
 *  **get(byte\[\] dst, int offset, int length)**： 从position位置开始相对读，读length个byte，并写入dst下标从offset到offset+length的区域

**写入数据**

*  put(byte b)：将给定单个字节写入缓冲区的当前位置
    
    > 相对写，向position的位置写入一个byte，并将postion+1，为下次读写作准备
 *  **put(byte\[\] src)**：将 src 中的字节写入缓冲区的当前位置
 *  **put(int index, byte b)**：将指定字节写入缓冲区的索引位置(不会移动 position)
    
    > 绝对写，向byteBuffer底层的bytes中下标为index的位置插入byte b，不改变position
 *  **put(ByteBuffer src)** 用相对写，把src中可读的部分（也就是position到limit）写入此byteBuffer
 *  **put(byte\[\] src, int offset, int length)** 从src数组中的offset到offset+length区域读取数据并使用相对写写入此byteBuffer

**其他操作**

*  `flip()`： 该方法就是用于切换读取数据模式，默认为写数据模式，
 *  > limit = position;position = 0;mark = -1; 翻转，也就是让flip之后的position到limit这块区域变成之前的0到position这块，翻转就是将一个处于存数据状态的缓冲区变为一个处于准备取数据的状态
    > 
    > > Buffer 中的 flip() 方法涉及到 Buffer 中的 capacity、position、limit三个概念。
    > > 
    > >  *  capacity：在读/写模式下都是固定的，就是我们分配的缓冲大小（容量）。
    > >  *  position：类似于读/写指针，表示当前读(写)到什么位置。
    > >  *  limit：在写模式下表示最多能写入多少数据，此时和capacity相同。在读模式下表示最多能读多少数据，此时和缓存中的实际 数据大小相同。
    
        //flip源码
        public final Buffer flip() { 
        	limit = position;
        	position = 0;
        	mark = -1;
        	return this;
        }
    
    > flip()：Buffer有两种模式，写模式和读模式。在写模式下调用flip()之后，Buffer从写模式变成读模式。  
    > 那么limit就设置成了position当前的值(即当前写了多少数据)，postion会被置为0，以表示读操作从缓存的头开始读，mark置为-1。  
    > 也就是说调用flip()之后，读/写指针position指到缓冲区头部，并且设置了最多只能读出之前写入的数据长度(而不是整个缓存的容量大小)。
 *  **rewind()**： 重复读,使position归0
    
    > 把position设为0，mark设为-1，不改变limit的值
 *  **clear()**： 清空缓冲区数据，将数据写入磁盘（`缓冲区中的数据依然存在，处于被遗忘状态`）
    
    > position = 0;limit = capacity;mark = -1; 有点初始化的味道，但是并不影响底层byte数组的内容
 *  **compact()**：把从position到limit中的内容移到0到limit-position的区域内，position和limit的取值也分别变成limit-position、capacity。如果先将positon设置到limit，再compact，那么`相当于clear()`
 *  **reset()**：position,limit,capacity恢复到mark记录的位置
    
    > 把position设置成mark的值，相当于之前做过一个标记，现在要退回到之前标记的地方
 *  **hasRemaining()**：是否还有剩余数据
    
    > return position < limit返回是否还有未读内容
 *  **remaining()**：如果还有剩余数据，返回剩余的数据量大小
    
    > return limit - position;返回limit和position之间相对位置差
 *  **capacity()** : 获取当前Buffer的最大容量
 *  **limit()** : 获取当前Buffer的读写界限
 *  **position()** : 获取当前Buffer的读写位置
 *  **mark()**：标记。mark会记录当前的position,limit,capacity

#### 2.1.3.如何读写Buffer的数据 ####

@Test
    public void readWrite() { 
    		String str = "abcde";
    		//1.分配一个指定大小的缓冲区
    		ByteBuffer buf = ByteBuffer.allocate(1024);
    		
    		//2.将数据存入缓冲区
    		buf.put(str.getBytes());
    
    		//3.切换到读取数据的模式
    		buf.flip();
    		
    		//4.读取数据并输出
    		byte[] bytes = new byte[buf.limit()];
    		buf.get(dst, 0, 2);
    		System.out.println(new String(bytes,0,bytes.length));
    	}

#### 2.1.4.Buffer的4个重要属性 ####

*  *capacity（`最大容量`）*: 表示缓冲区中`最大存储数据的容量`，不能为负且一但声明不能改变。(因为底层是`数组`，数组一但被创建就不能被改变)
 *  *limit (`读写界限`)*：表示缓冲区的当前终点，`不能对缓冲区超过极限的位置进行读写操作`。且界限是可以修改的。不能为负且不能大于其容量（capacity）
 *  *position （`读写位置`）*：表示缓冲区中`下一个要读取或写入的数据的索引位置，每次读写缓冲区数据时都会改变改值，为下次读写作准备`。不能为负，并且不能大于其限制（limit ）
 *  *mark（`标记`）* :标记，调用mark()来设置mark=position ，再调用reset()方法可以让position恢复到mark标记的位置，即 mark=position

**这4个属性之间总是遵循以下关系：**

> **0 <= mark <= position <= limit <= capacity**  
> ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 12]

#### 2.1.5.直接缓冲区与非直接缓存区 ####

*  非直接缓冲区：通过`allocate()`方法分配缓冲区，**将缓冲区建立在 JVM 的内存中**
 *  直接缓冲区：通过`allocateDirect()`方法分配直接缓冲区，**将缓冲区建立在物理内存中。可以提高效率**

//创建非直接缓冲区
    ByteBuffer buf1 = ByteBuffer.allocate(1020);
    //创建直接缓冲区
    ByteBuffer buf2 = ByteBuffer.allocateDirect(1024);
    //判断是否为直接缓冲区
    System.out.println(buf2.isDirect());

**字节缓冲区要么是直接缓冲区，要么是非直接缓冲区。如果为直接字节缓冲区，则JVM会尽最大努力直接在此缓冲区上执行本机 I/O 操作。也就是说，在每次调用基础操作系统的一个本机 I/O 操作之前（或之后），虚拟机都会尽量避免将缓冲区的内容复制到直接缓冲区中（或从直接缓冲区中复制内容）**。

1.  直接字节缓冲区通过`该对象的 allocateDirect()`来创建。**此方法返回的缓冲区，进行分配和取消分配所需成本通常`高于非直接缓冲区`**。
2.  直接字节缓冲区还可以过 通过`FileChannel 的 map()`方法`将文件区域直接映射到内存中来创建`。该方法返回`MappedByteBuffer`。
3.  `isDirect()`可以判断字节缓冲区是直接缓冲区还是非直接缓冲区。

> 解释：左边的是操作系统（OS），右边是Java虚拟机(JVM),应用程序无论是读操作还是写操作都必须在OS和JVM之间进行复制。

##### 1.非接缓存区 #####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 13]

解释：当我们的程序想要从硬盘中读取数据 需要

1.  先从`物理硬盘`把数据读取到`物理内存`中
2.  再将内容复制到`JVM的内存`中
3.  然后应用程序才可以读取到内容

读写都是这样需要复制这一个动作 当遇到大文本的文件时 效率及其低下.

##### 2.直接缓存区 #####

![\*\*加粗样式\*\*][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 14]

解释：在NIO中，直接开辟物理内存映射文件，应用程序直接操作`物理内存映射文件`，`由用户空间和物理内存直接交互，少了数据到内核空间的这一步，`，可以极大得提高读写效率。**但这种方式也存在一个问题，`消耗的内存会增大`，内存的释放只能通过Java的垃圾回收机制来释放，并不是一不使用就回收。**

#### 2.1.6.Buffer的代码示例 ####

**Buffer的使用步骤**

1.  调用Buffer.allocate()方法\`，创建一个Buffer类的实例对象。
2.  调用Buffer实例对象的`put方法`，将数据写入到缓冲区中。
3.  写入完成后，在开始读取数据前，调用`Buffer.flip()方法`，将缓冲区转换为读模式。
4.  调用get方法，从缓冲区中读取数据。
5.  读取完成后，调用`Buffer.clear()`或 `Buffer.compact()`方法，将缓冲区转换为写入模式(清除缓冲区)。

public class BufferDemo { 
        public static void main(String[] args) { 
            System.out.println("================创建Buffer实例对象=======================");
            //[1] 创建Buffer实例对象
            //申请堆内内存 allocateDirect 申请堆外内存
            ByteBuffer buffer = ByteBuffer.allocate(4);
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
    
            //[2] 缓存区默认为写模式，将数据写入缓存区
            System.out.println("================缓存区默认为写模式，将数据写入缓存区=======================");
            buffer.put((byte) 1);
            buffer.put((byte) 2);
            buffer.put((byte) 3);
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
    
            //[3] 将缓存区转换为读模式
            buffer.flip();
            System.out.println("================将缓存区转换为读模式=======================");
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
    
            //从缓存区读取数据
            System.out.println("================从缓存区读取数据=======================");
            buffer.get();
            buffer.get();
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
    
    
            //[4] 将缓存区换为写模式
            System.out.println("================将缓存区换为写模式=======================");
            // buffer.clear(); Or buffer.compact();
            //清除已读的元素
            buffer.compact();
            buffer.put((byte) 4);
            buffer.put((byte) 5);
            buffer.put((byte) 6);
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
    
            //[5] 重置positon位置，即从头来一次！
            System.out.println("================重置positon位置=======================");
            buffer.rewind();
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
    
            //[6] Mark和Reset
            buffer.mark();
            System.out.println("================mark=======================");
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
    
            System.out.println("================reset=======================");
            buffer.reset();
            System.out.println("buffer===positon:" + buffer.position() + ",capacity:" + buffer.capacity() + ",limit:" + buffer.limit());
        }
    }

**执行结果**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 15]

### 2.2.Channel(通道) ###

#### 2.2.1.概念 ####

**Channel表示 IO 源与目标打开的连接** ，与流不同，通道可以理解成一个`双向流`或一个`通道`，**数据可以从 Channel 流进 Buffer ，也可以从 Buffer 流进 Channel**

Channel 提供的API涵盖了TCP/UPD和文件IO，`常用实现类`的有以下4个

*  `FileChannel` ：文件通道：用于**文件数据的读写**
 *  `SocketChannel` ：套接字通道 ：**用于TCP协议的数据读写**
 *  `ServerSocketChannel` ：服务端套接字通道 ：**用于监听TCP请求，为每个监听的请求创建一个SocketChannel套接字通道**。
    
    > 用于监听TCP请求，如果该通道为非阻塞模式，那么如果没有挂起的连接，该方法立即返回null。`必须检查放回的SocketChannel 是否为null`
 *  DatagramChannel：数据报通道：**用于UDP协议的数据读写**

#### 2.2.2.Channel的常用方法 ####

*  **int read(ByteBuffer dst)** 从 Channel 中读取数据到 ByteBuffer
 *  **long read(ByteBuffer\[\] dsts)** 将 Channel 中的数据“分散”到 ByteBuffer\[\]
 *  **int write(ByteBuffer src)** 将 ByteBuffer 中的数据写入到 Channel
 *  **long write(ByteBuffer\[\] srcs)** 将 ByteBuffer\[\] 中的数据“聚集”到 Channel
 *  **long position()** 返回此通道的文件位置
 *  **FileChannel position(long p)** 设置此通道的文件位置
 *  **long size()** 返回此通道的文件的当前大小
 *  **FileChannel truncate(long s)** 将此通道的文件截取为给定大小
 *  **void force(boolean metaData)** 强制将所有对此通道尚未写入磁盘的数据强制写到磁盘上

#### 2.2.2.Channel的代码示例 ####

##### 1.FileChannel的使用(常用) #####

###### 1.1.概念 ######

`FileChannel是专门操作文件的通道，它能直接连接输入输出流的文件通道，将数据直接写入到目标文件中去。而且效率更高。`。虽然FileChannel是Java NIO的一部分，但是FileChannel操作是阻塞的，并且没有非阻塞模式。

**优点:**

1.  在文件特定位置进行读写操作
2.  将文件一部分直接加载到内存，这样效率更高
3.  以更快的速度将文件数据从一个通道传输到另一个通道
4.  锁定文件的某一部分来限制其他线程访问
5.  为了避免数据丢失，强制立即将更新写入文件并存储

###### 1.2.通道获取 ######

获取通道的一种方式是对支持通道的对象调用`getChannel()`方法。支持通道的类如下:

*  FileInputStream
 *  FileOutputStream
 *  RandomAccessFile
 *  DatagramSocket
 *  Socket
 *  ServerSocket

> **JDK1.7后可以是通过`Files.newByteChannel() 方`法或者一条字节通道，或通过文件通道`FileChannel.open()`方法打开一条通道**

**1.从 FileInputStream / FileOutputStream 中获取**

*  从 FileInputStream 对象中获取的通道是以读的方式打开文件，从 FileOutpuStream 对象中获取的通道是以写的方式打开文件。

FileOutputStream ous = new FileOutputStream(new File("a.txt"));
    FileChannel out = ous.getChannel(); // 获取一个只读通道
    FileInputStream ins = new FileInputStream(new File("a.txt"));
    FileChannel in = ins.getChannel(); // 获取一个只写通道

**2 从 RandomAccessFile 中获取**

*  从 RandomAccessFaile 中获取的通道取决于`RandomAccessFaile` 对象是以什么方式创建的，`"r", "w", "rw"`分别对应着`读模式，写模式，以及读写模式`。

RandomAccessFile file = new RandomAccessFile("a.txt", "rw");
    FileChannel channel = file.getChannel(); // 获取一个可读写文件通道

**3.通过 FileChannel.open() 打开**

*  通过静态静态方法`FileChannel.open()`打开的通道可以指定打开模式，模式通过`StandardOpenOption 枚举类型`指定。

FileChannel channel = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.READ); // 以只读的方式打开一个文件 a.txt 的通道

**StandardOpenOption**  
在打开文件通道时可以选择的模式有很多，其中最常见的是READ和WRITE模式，分别通过`java.nio.file.StandardOpenOption枚举类型`中的`READ`和`WRITE`来声明。

*  `READ`：读取一个已存在的文件，如果文件不存在或被占用则抛出异常
 *  `WRITE`： 以追加到文件头部的方式，写入一个已存在的文件，如果文件不存在或被占用则抛出异常
 *  `APPEND` ： 以追加到文件尾部的方式，写入一个已存在的文件，如果文件不存在或被占用则抛出异常
 *  `TRUNCATE_EXISTING`：如果文件已经存在，那么它的内容将被清空；
 *  `CREATE` 创建一个空文件，如果文件存在则不创建
 *  `CREATE_NEW` 创建一个空文件，如果文件存在则报错
 *  `DELETE_ON_CLOSE` ：用在创建临时文件时, 当流和管道关闭时删除文件，如果流和管道没有关闭，则在Java虚拟机退出时删除文件
 *  SPARSE： 创建稀疏文件，与CREATE\_NEW选项配合使用。
 *  SYNC ：要求每次写入要把内容和元数据写入磁盘。
 *  DSYNC ：要求每次写入时内容直接写磁盘

###### 1.3.分散读取(Scatter Reads)和聚集写入(Gather Writes) ######

**1. 分散读取(Scattering Reads)是指将从 Channel 中读取是将数据读入多个 Buffer 的操作**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 16]

> 注意:按照缓冲区的顺序，从 Channel 中读取的数据依次将 Buffer 填满。

**2. 聚集写入(Gathering Writes)是指将将来自多个Buffer 的数据写入单个Channel 的操作**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 17]

> 注意:按照缓冲区的顺序，写入 position 和 limit 之间的数据到 Channel 。

@Test
        public void test4() throws IOException { 
            RandomAccessFile raf1 = new RandomAccessFile("1.txt", "rw");
    
            //1. 获取通道
            FileChannel channel1 = raf1.getChannel();
    
            //2. 分配指定大小的缓冲区
            ByteBuffer buf1 = ByteBuffer.allocate(100); // 分配第1个缓冲区，大小为 100
            ByteBuffer buf2 = ByteBuffer.allocate(4096);// 分配第1个缓冲区，大小为 4096
            //分散读取
            ByteBuffer[] bufs = { buf1, buf2};
             // 一次性读入2个缓冲区的数据到通道中
            channel1.read(bufs);
    
            for (ByteBuffer byteBuffer : bufs) { 
            	 // 将 buffer 从写入模式切换为读取模式,将换重启
                byteBuffer.flip();
            }
            System.out.println(new String(bufs[0].array(), 0, bufs[0].limit()));
            System.out.println("---------------------------");
            System.out.println(new String(bufs[1].array(), 0, bufs[1].limit()));
    
            //聚集写入
            RandomAccessFile raf2 = new RandomAccessFile("2.txt", "rw");
            FileChannel channel2 = raf2.getChannel();
    
            channel2.write(bufs);
        }

**分散读取**

*  注意`多个Buffer首先插入到数组`中，然后将数组作为参数传递给`channel.read()`。 然后，**read()方法按照`缓冲区在数组中出现的顺序`从通道写入数据。 `一旦缓冲区已满，通道就会继续填充下一个缓冲区`**。
 *  分散读取在移动到下一个缓冲区之前，必须先填充满前一个缓冲区，这意味着`它不适合大小不固定的数据`。

**聚集写入**

*  将`Buffer数组传递给 write()`，**该方法按照在`数组的顺序写入缓冲区的内容到单个通道`，注意仅写入缓冲区的 position 和 limit 之间的数据**。
 *  因此，如果缓冲区的容量为 100字节，但只包含 58 字节的内容，则只有 58 字节从该缓冲区写入通道。 因此，与 *分散读取* 相比，*聚集写入* 可以`适应大小不固定的数据，因为它只把包含内容部分的缓冲区写入到通道`。

###### 1.4.读取数据 ######

*  读取数据的`read(ByteBuffer buf)`方法返回的值表示读取到的字节数，`如果读到了文件末尾，返回值为 -1`。**读取数据时，position 会往后移动**。

**1 将数据读取到单个缓冲区**

*  和一般通道的操作一样，数据也是需要读取到1个缓冲区中，然后从缓冲区取出数据。在调用 read 方法读取数据的时候，可以传入参数 `position 和 length`来指定开始读取的位置和长度。

FileChannel channel = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.READ);
    ByteBuffer buf = ByteBuffer.allocate(5);
    
    while(channel.read(buf)!=-1){ 
     buf.flip();
     System.out.print(new String(buf.array()));
     buf.clear();
    }
    
    channel.close();

> `read()方法·`：该方法将数据从FileChannel读取到Buffer中。read()方法返回的`int值表示了有多少字节被读到了Buffer中。如果返回-1，表示到了文件末尾`。

**2.读取到多个缓冲区**

*  文件通道 FileChannel 实现了 `ScatteringByteChannel 接口`，可以将文件通道中的内容`同时读取到多个 ByteBuffer 当中`，这在处理包含若干长度固定数据块的文件时很有用。

ScatteringByteChannel channel = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.READ);
    ByteBuffer key = ByteBuffer.allocate(5), value=ByteBuffer.allocate(10);
    ByteBuffer[] buffers = new ByteBuffer[]{ key, value};
    
    while(channel.read(buffers)!=-1){ 
     key.flip();
     value.flip();
     System.out.println(new String(key.array()));
     System.out.println(new String(value.array()));
     key.clear();
     value.clear();
    }
    
    channel.close();

**3.获取设置文件通道读取、或者写入位置**

*  有时可能需要在文件通道的某个特定位置进行数据的读/写操作。可以通过调用`position()`方法获取文件的当前位置。也可以通过调用`position(long pos)`方法设置FileChannel的当前位置

**4.获取文件通道所关联文件的大小: size()方法**

###### 1.5.写入数据 ######

**1.从单个缓冲区写入**

*  单个缓冲区操作也非常简单，它返回往通道中写入的字节数。

FileChannel channel = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.WRITE);
    ByteBuffer buf = ByteBuffer.allocate(5);
    
    byte[] data = "Hello, Java NIO.".getBytes();
    for (int i = 0; i < data.length; ) { 
     buf.put(data, i, Math.min(data.length - i, buf.limit() - buf.position()));
     buf.flip();
     i += channel.write(buf);
     buf.compact();
    }
    
    channel.force(false);
    channel.close();

> **`注意`**: **FleChanne写入的时候并不保证能一次性写入到文件中，所以需要进行判断是否全部写入，如果没有需要再次调用write()写入，因此可以通过while循环`buffer.hasRemaining()`判断缓冲区是否还有未写入通道的数据, 伪代码如下**

byteBuffer.clear();
    byteBuffer.put("需要写入的数据".getBytes());
    //类似于flush()函数功能，将buffer里面的数据刷新出去
    byteBuffer.flip();
    //检查是否还有数据未写入
    while (byteBuffer.hasRemaining()) { 
    	fileChannel.write(byteBuffer)
    }

**2.从多个缓冲区写入**

*  FileChannel 实现了 `GatherringByteChannel 接口`，与 ScatteringByteChannel 相呼应。可以`一次性将多个缓冲区的数据写入到通道中`。

FileChannel channel = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.WRITE);
    ByteBuffer key = ByteBuffer.allocate(10), value = ByteBuffer.allocate(10);
    
    byte[] data = "017 Robothy".getBytes();
    key.put(data, 0, 3);
    value.put(data, 4, data.length-4);
    ByteBuffer[] buffers = new ByteBuffer[]{ key, value};
    
    key.flip();
    value.flip();
    
    channel.write(buffers);
    channel.force(false); // 将数据刷出到磁盘
    channel.close();

**3.数据刷出**

*  为了减少访问磁盘的次数，处于性能方面的考虑，通过文件通道对文件进行操作之后可能不会立即写到磁盘，操作系统会将数据缓存在内存中，此时如果系统崩溃，将导致数据的丢失。为了减少这种风险，在进行了重要数据的操作之后应该`调用 force() 方法强制将通道里尚未写入磁盘的数据强制写到磁盘上`。
    
     *  force()方法有一个boolean类型的参数，指明是否同时将文件元数据（权限信息等）写到磁盘上。
     *  无论是否对文件进行过修改操作，即使文件通道是以只读模式打开的，只要调用了 force(metaData) 方法，就会进行一次 I/O 操作。

channel.force(false); // 将数据刷出到磁盘，但不包括元数据

###### 1.6.文件锁 ######

可以通过调用 FileChannel 的`lock() 或者 tryLock()` 方法来获得一个`文件锁`，获取锁的时候可以指定`参数起始位置 position`，`锁定大小 size`，`是否共享 shared`。**如果没有指定参数，`默认`参数为 position = 0, size = Long.MAX\_VALUE, shared = false。**

*  `位置 position 和大小 size 不需要严格与文件保持一致`，position 和 size 均可以超过文件的大小范围。
    
     *  例如：文件大小为 100，可以指定位置为 200， 大小为 50；则当文件大小扩展到 250 时，\[200,250) 的部分会被锁住。
 *  `shared 参数指定是排他的还是共享的`。要获取共享锁，文件通道必须是可读的；要获取排他锁，文件通道必须是可写的。
    
     *  `由于 Java 的文件锁直接映射为操作系统的文件锁实现，因此获取文件锁时代表的是整个虚拟机，而非当前线程`。若操作系统不支持共享的文件锁，即使指定了文件锁是共享的，也会被转化为排他锁。

FileLock lock = channel.lock(0, Long.MAX_VALUE, false);// 排它锁，此时同一操作系统下的其它进程不能访问 a.txt
    System.out.println("Channel locked in exclusive mode.");
    Thread.sleep(30 * 1000L); // 锁住 30 s
    lock.release(); // 释放锁
     
    lock = channel.lock(0, Long.MAX_VALUE, true); // 共享锁，此时文件可以被其它文件访问
    System.out.println("Channel locked in shared mode.");
    Thread.sleep(30 * 1000L); // 锁住 30 s
    lock.release();

*  lock() 会阻塞，直到获取到了锁、通道被关闭或者线程被中断为止，`tryLock() 是非阻塞的`，`无论是否能够获取到锁，它都会立即返`回。若 tryLock()`请求锁定的区域已经被操作系统内的其它的进程锁住了，则返回 null`；
 *

###### 1.7.通道间数据传输 ######

普通的读写方式是利用一个 ByteBuffer 缓冲区，作为数据的容器。但如果是两个通道之间的数据传输，利用缓冲区作为媒介是多余的，所以下面两个操作都是 **映射文件到`直接缓冲区`来进行数据传输的** ？什么是直接缓冲区？

*  文件通道允许从一个`ReadableByteChannel 中直接读取数据`，也允许`直接往 WritableByteChannel 中写入数据`。可以通过下面2个方法实现通道间的数据传输：
    
     *  **transferFrom(ReadableByteChannel src, position, count)**
        
         *  表示将`通道src的数据`传到`调用transferFrom的通道`中： 1.输入管道信息、2.起始位置信息、 3.输入的最大值。
         *  示例如下：
    
        //输入源
        FileChannel inChannel = FileChannel.open( Paths.get("/home/img/1.png" ), StandardOpenOption.READ );
        //输出源
        FileChannel outChannel = FileChannel.open( Paths.get( "/home/img/2.png") , StandardOpenOption.READ , StandardOpenOption.WRITE , StandardOpenOption.CREATE );
        //将inChannel的数据传输到outChannel中,起始位置信息0,读取的最大值为inChannel的大小
        outChannel.transferFrom( inChannel , 0 , inChannel.size() );
        //关闭输入输出通道
        inChannel.close();
        outChannel.close();
    
     *  **transferTo(position, count, WritableChannel target)**
        
         *  表示将`调用transferTo的通道数据`传到`通道target`中： 1.起始位置信息、2.输入的最大值 、3.输出管道信息。
         *  示例如下：
    
        //输入源
        FileChannel inChannel = FileChannel.open( Paths.get("/home/img/1.png" ), StandardOpenOption.READ );
        //输出源
        FileChannel outChannel = FileChannel.open( Paths.get( "/home/img/2.png") , StandardOpenOption.READ , StandardOpenOption.WRITE , StandardOpenOption.CREATE );
        //将inChannel的数据传输到outChannel中,起始位置信息0,读取的最大值为inChannel的大小
        inChannel.transferTo( 0, inChannel.size(), outChannel );
        //关闭输入输出通道
        inChannel.close();
        outChannel.close();
    
    > `transferFrom 或者 transferTo` 功能效果是一样的，但在调用之后并不会改变`position` 的位置。\`

**需要注意的是**：调用这2个方法`某些情况下并不保证数据能够全部完成传输`，`确切传输了多少字节的数据需要根据返回的值来进行判断`。

*  例如：从一个非阻塞模式下的 SocketChannel 中输入数据就不能够一次性将数据全部传输过来，或者将文件通道的数据传输给一个非阻塞模式下的 SocketChannel 不能一次性传输过去。

/** 服务端 **/
    // 打开服务通道
    ServerSocketChannel serverSocketChannel = ServerSocketChannel.open(); 
    // 绑定端口号
    serverSocketChannel.bind(new InetSocketAddress(9090));
    // 等待客户端连接，获取 SocketChannel
    SocketChannel clientChannel = serverSocketChannel.accept();
     // 打开文件通道
    FileChannel fileChannel = FileChannel.open(Paths.get("video.mp4"), StandardOpenOption.READ);
    // 【可能出错位置】文件通道数据输出转化到 socket 通道，输出范围为整个文件。文件太大将导致输出不完整
    fileChannel.transferTo(0, fileChannel.size(), clientChannel); 
    
    
    /** 客户端 **/
     // 打卡 socket 通道并连接到服务端
    SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("localhost", 9090));
    // 打开文件通道
    FileChannel fileChannel = FileChannel.open(Paths.get("video-downloaded.mp4"), StandardOpenOption.TRUNCATE_EXISTING, StandardOpenOption.WRITE, StandardOpenOption.CREATE); 
    // 【非阻塞模式下可能出错】
    fileChannel.transferFrom(socketChannel, 0, Long.MAX_VALUE); 
     // 确保数据刷出到磁盘
    fileChannel.force(false);

**正确的姿势是**：`transferTo/transferFrom` 的时候应该`用一个循环检查实际输出内容大小是否和期望输出内容大小一致`，特别是通道处于非阻塞模式下，极大概率不能够一次传输完成。

long transfered = 0;
    while (transfered < fileChannel.size()){ 
     transfered += fileChannel.transferTo(transfered, fileChannel.size(), clientChannel);
    }

###### 1.8.截取文件 ######

*  `FileChannel.truncate(long size)` 可以截取指定的文件，`指定长度后面的部分将被丢弃`。**size 的值可以超过文件大小，超过的话不会截取任何内容，也不会增加任何内容。**

FileChannel fileChannel = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.WRITE);
    fileChannel.truncate(1);
    System.out.println(fileChannel.size()); // 输出 1
    
    fileChannel.write(ByteBuffer.wrap("Hello".getBytes()));
    System.out.println(fileChannel.size()); // 输出 5
    
    fileChannel.force(true);
    fileChannel.close();

###### 1.9.映射文件到直接缓冲区 ######

*  文件通道 FileChannel 可以将文件的指定范围映射到程序的地址空间中，映射部分使用字节缓冲区的一个子类 **MappedByteBuffer** 的对象表示，只要对`映射字节缓冲区`进行操作就能够达到操作文件的效果。与之相对应的，`前面`介绍的内容是通过`操作文件通道和堆内存中的字节缓冲区 HeapByteBuffer 来达到操作文件的目的`。
    
     *  通过`ByteBuffer.allocate()`分配的缓冲区是一个 `HeapByteBuffer`，存在于`JVM 堆`中；而`FileChannle.map()` 将文件映射到`直接缓冲区`，返回的是一个 `MappedByteBuffer`，存在于`堆外的直接缓冲区`中；**这块内存在 MappedByteBuffer 对象本身被回收之前有效。**

**1 内存映射原理**

*  前面使用**堆缓冲区 ByteBuffer 和文件通道 FileChannel** 对文件的操作使用的是`read()/write() 系统调用`。*读取数据时数据从 I/O 设备读到内核缓存，再从内核缓存复制到用户空间缓存，这里是 `JVM 的堆内存`*。而`映射磁盘文件是使用mmap() 系统调用，将文件的指定部分映射到程序地址空间中`；**数据交互发生在 I/O 设备于用户空间之间，不需要经过内核空间。**
 *  虽然映射磁盘文件减少了一次数据复制，但对于大多数操作系统来说，将文件映射到内存这个操作本身开销较大；如果操作的文件很小，只有数十KB，映射文件所获得的好处将不及其开销。**`因此，只有在操作大文件的时候才将其映射到直接内存`。**

**2 映射缓冲区用法**

*  文件通道 FileChanle 通过成员方法`map(MapMode mode, long position, long size)`将文件映射到应用内存。
 *  mode 表示`打开模式`，为枚举值
    
    >  *  FileChannel.MapMode PRIVATE ：私有（写时复制）映射的模式。
    >  *  FileChannel.MapMode READ\_ONLY ：只读映射的模式。
    >  *  FileChannel.MapMode READ\_WRITE  
    >     读/写映射的模式。
 *  position 指定文件的开始映射到内存的位置；
 *  size 指定映射的大小，值为非负 int 型整数。

/** * 使用直接缓冲区完成文件的复制（内存映射文件） */
        @Test
        public void test2() throws IOException { 
            FileChannel inChannel = FileChannel.open( Paths.get( "/Users/huanchu/Documents/1.png" ) , StandardOpenOption.READ );
            FileChannel outChannel = FileChannel.open( Paths.get( "/Users/huanchu/Documents/2.png" ) , StandardOpenOption.READ , StandardOpenOption.WRITE , StandardOpenOption.CREATE);
     
            //内存映射文件
            MappedByteBuffer inMappedBuf = inChannel.map( FileChannel.MapMode.READ_ONLY, 0, inChannel.size() );
            MappedByteBuffer outMappedBuf = outChannel.map( FileChannel.MapMode.READ_WRITE, 0, inChannel.size() );
     
            //直接对缓冲区进行数据的读写操作
            byte[] dst = new byte[inMappedBuf.limit()];
            inMappedBuf.get( dst );
            outMappedBuf.put( dst );
     
            inChannel.close();
            outChannel.close();
        }

`调用 map() 方法之后，返回的 MappedByteBuffer 就于 fileChannel 脱离了关系，关闭 fileChannel 对 buf 没有影响`。同时，如果**要确保对 buf 修改的数据能够同步到文件 I/O 设备中**，需要`调用 MappedByteBuffer 中的无参数的 force() 方法`，而调用 FileChannel 中的 force(metaData) 方法无效。

*  此时可以`通过操作缓冲区来操作文件`了。不过`映射的内容存在于 JVM 程序的堆外内存中`，这部分内存是`虚拟内存`，意味着 buf 中的内容不一定都在物理内存中，要让这些内容加载到物理内存，可以`调用 MappedByteBuffer 中的 load() 方法`。另**外，还可以调用 isLoaded() 来判断 buf 中的内容是否在物理内存中。**

FileChannel fileChannel = FileChannel.open(Paths.get("a.txt"), StandardOpenOption.WRITE, StandardOpenOption.READ);
    MappedByteBuffer buf = fileChannel.map(FileChannel.MapMode.READ_WRITE, 0, fileChannel.size());
     // 关于文件通道对 buf 没有影响
    fileChannel.close();
     // 输出 fileChannel.size()
    System.out.println(buf.capacity());
    // 输出 fileChannel.size()
    System.out.println(buf.limit()); 
    System.out.println(buf.position()); // 输出 0
    // 写入内容
    buf.put((byte)'R'); 
    // 截掉 positoin 之前的内容
    buf.compact();  
     // 将数据刷出到 I/O 设备
    buf.force();

###### 1.10.小结 ######

1.  文件通道 FileChannel 能够将数据从 I/O 设备中读入(read)到字节缓冲区中，或者将字节缓冲区中的数据写入(write)到 I/O 设备中。
2.  文件通道能够`转换到 (transferTo) 一个可写通道`中，也可以`从一个可读通道转换而来（transferFrom）`。这种方式**使用于通道之间地数据传输，比使用IO缓冲区更加高效。**
3.  **文件通道能够将文件的部分内容映射（map）到`JVM 堆外内存`中，这种方式`适合处理大文件`，`不适合处理小文件`，因为映射过程本身开销很大。**
4.  在对文件进行重要的操作之后，应该`将数据刷出(force)到磁盘，避免操作系统崩溃导致的数据丢失`。

##### 2.SocketChannel的使用 #####

###### 2.1.NIO客户端-版本1 ######

public class NioClient1 { 
        private static int port = 8080;
        private static SocketChannel socketChannel = null;
        private static int bufferSize = 1024;
    
        public static void main(String[] args) throws IOException { 
            socketChannel = SocketChannel.open();
    
            //设置为非阻塞 默认为不阻塞
            socketChannel.configureBlocking(false);
    
            //连接指定的服务器路径
            socketChannel.connect(new InetSocketAddress("localhost", port));
    
            //如果没有连接成功就等待
            while (!socketChannel.finishConnect()) { 
                Thread.yield();
            }
            
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入：");
            String msg = scanner.nextLine();
    
            //发送数据
            ByteBuffer writeBuffer = ByteBuffer.wrap(msg.getBytes());
            //如果有数据
            while (writeBuffer.hasRemaining()) { 
                //往服务器写入数据
                socketChannel.write(writeBuffer);
            }
    
            System.out.println("读取服务器数据");
            ByteBuffer readBuffer = ByteBuffer.allocate(bufferSize);
            while (socketChannel.isOpen() && socketChannel.read(readBuffer) != 1) { 
                if (readBuffer.position() > 0) { 
                    break;
                }
            }
            
            //读取数组中的数据
            readBuffer.flip();
            //长度为readBuffer的读取界限
            byte[] bytes = new byte[readBuffer.limit()];
            readBuffer.get(bytes);
            System.out.println(new String(bytes));
            
            //断开连接
            scanner.close();
            socketChannel.close();
        }
    }

###### 2.2.NIO服务端-版本1 ######

**在这种方式下等待连接时和等待数据时都不会阻塞**

public class NioServer1 { 
        public static void main(String[] args) throws IOException, InterruptedException { 
            //打开通道
            ServerSocketChannel socketServer = ServerSocketChannel.open();
            //设置为非阻塞
            socketServer.configureBlocking(false);
            //绑定端口
            socketServer.bind(new InetSocketAddress(8080));
            System.out.println("启动成功");
            while (true) { 
                SocketChannel socketChannel = socketServer.accept();
                if (socketChannel != null) { 
                    System.out.println("接受到新的连接：" + socketChannel.getRemoteAddress());
                    socketChannel.configureBlocking(false);
    
                    //读取数据
                    ByteBuffer readBuffer = ByteBuffer.allocate(1024);
                    while (socketChannel.isOpen() && socketChannel.read(readBuffer) != -1) { 
                        //数据读取完了
                        if (readBuffer.position() > 0) { 
                            break;
                        }
                    }
                    //读取不到数据
                    if (readBuffer.position() == 0) { 
                        continue;
                    }
    
                    //切换成读取数据模式
                    readBuffer.flip();
                    //读取缓存数据
                    byte[] bytes = new byte[readBuffer.limit()];
                    readBuffer.get(bytes);
                    System.out.println("接到连接的数据：" + new String(bytes));
    
                    //返回数据给客户端,将缓冲区数据写入通道
                    // 响应结果 200
                    String response = "HTTP/1.1 200 OK\r\n" + "Content-Length: 11\r\n\r\n" + "Hello World";
                    ByteBuffer writeBuffer = ByteBuffer.wrap(response.getBytes());
                    while (writeBuffer.hasRemaining()) { 
                        socketChannel.write(writeBuffer);// 非阻塞
                    }
                }
                //表示没人连接
                else { 
                    TimeUnit.MILLISECONDS.sleep(5000);
                    System.out.println("无连接。。。。");
                }
            }
        }
    }

客户端-NioClient1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 18]

客户端-NioServer1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 19]

###### 2.3.NIO服务端-版本2 ######

缓存Socket，轮询数据是否准备好

public class NioServer2 { 
        //保存有效通道
        private static ArrayList<SocketChannel> socketChannels = new ArrayList<>();
    
        public static void main(String[] args) throws IOException, InterruptedException { 
            //打开通道
            ServerSocketChannel socketServer = ServerSocketChannel.open();
            //设置为非阻塞
            socketServer.configureBlocking(false);
            //绑定端口
            socketServer.bind(new InetSocketAddress(8080));
            System.out.println("启动成功");
            while (true) { 
                SocketChannel socketChannel = socketServer.accept();
                if (socketChannel != null) { 
                    System.out.println("接受到新的连接：" + socketChannel.getRemoteAddress());
                    //读取数据
                    socketChannel.configureBlocking(false);
                    socketChannels.add(socketChannel);
                }
                //没人连接时,处理缓存的有效连接
                else { 
                    TimeUnit.MILLISECONDS.sleep(2000);
                    System.out.println("......无连接。。。。");
                    Iterator<SocketChannel> iterator = socketChannels.iterator();
                    while (iterator.hasNext()) { 
                        SocketChannel next = iterator.next();
                        ByteBuffer readBuffer = ByteBuffer.allocate(1024);
    
                        //读取不到数据
                        if (next.read(readBuffer) == 0) { 
                            continue;
                        }
                        //读取不到数据
                        if (readBuffer.position() == 0) { 
                            continue;
                        }
    
                        //切换成读取数据模式
                        readBuffer.flip();
                        //读取缓存数据
                        byte[] bytes = new byte[readBuffer.limit()];
                        readBuffer.get(bytes);
                        System.out.println("接到连接的数据：" + next.getRemoteAddress()+":"+new String(bytes));
    
                        //返回数据给客户端,将缓冲区数据写入通道
                        // 响应结果 200
                        String response = "HTTP/1.1 200 OK\r\n" + "Content-Length: 11\r\n\r\n" + "Hello World";
                        ByteBuffer buffer = ByteBuffer.wrap(response.getBytes());
                        while (buffer.hasRemaining()) { 
                            next.write(buffer);// 非阻塞
                        }
                        //释放当前连接
                        iterator.remove();
                    }
                }
            }
        }
    }

客户端-NioClient1  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 20]

服务端-NioServer2  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 21]

**代码解析**

*  在**NIO服务端-版本1**中，我们采用了`非阻塞方式`，但是发现**一旦非阻塞，等待客户端发送消息时就不会再阻塞了，而是直接重新去获取新客户端的连接请求，这就会造成`客户端连接丢失`**
 *  而 **.NIO服务端-版本2**中，我们将`连接`存储在一个`list集合`中，每次`等待客户端消息`时都去`轮询`，看看消息是否准备好，如果准备好则直接打印消息。

可以看到，从头到尾我们一直没有开启第二个线程，而是一直采用`单线程来处理多个客户端的连接`，这样的一个模式可以很完美地解决`BIO在单线程模式下无法处理多客户端请求的问题，并且解决了非阻塞状态下连接丢失的问题。`

**解决版本2存在的问题**

*  从刚才的运行结果中其实可以看出，消息没有丢失，程序也没有阻塞。但是，在接收消息的方式上可能有些许不妥，我们采用了一个`轮询的方式来接收消息`，每次都**轮询所有的连接，看消息是否准备好**，测试用例中只是三个连接，所以看不出什么问题来，但是我们假设有1000万连接，甚至更多，采用这种轮询的方式效率是极低的。
    
    另外，1000万连接中，我们可能只会有100万会有消息，剩下的900万并不会发送任何消息，那么这些连接程序依旧要每次都去轮询，这显然是不合适的。

##### 3.真实NIO中如何解决这些问题 #####

*  在真实NIO中，`并不会在Java层上来进行一个轮询`，而是**将轮询的这个步骤交给我们的`操作系统`来进行**，他**将轮询的那部分代码改为操作系统级别的系统调用**（`window系统为select()函数，linux系统中为epoll()函数`），在操作系统级别上调用`select函数`，**主动地去感知有数据的socket。**

**select、poll、epoll**

*  `select，poll，epoll都是IO多路复用的机制`，这些调用都是`内核`级别的。本质上都是`同步I/O`，先是**阻塞住等待就绪的socket**，再是**阻塞住将数据从内核拷贝到用户内存**。  
    [select、poll、epoll之间的区别总结][select_poll_epoll]

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 22]

##### 4.关于select/poll/epoll和直接在应用层做轮询的区别 #####

我们在之前实现了一个使用Java做`多个客户端连接轮询的逻辑`，但是在**真正的NIO源码中其实并不是这么实现的**

*  **NIO使用了`操作系统底层的轮询系统`调用`select/epoll函数(windows:select(),linux:epoll())`**

那么为什么不直接在代码中实现而要在*底层通过操作系统*来做轮询呢？

**select函数底层逻辑**

*  假设有`A、B、C、D、E` 5个连接`同时连接服务器`，那么根据我们上文中的设计，`程序将会遍历这5个连接，轮询每个连接，获取各自数据准备情况`，那么和我们自己写的程序有什么区别呢？  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 23]  
    首先，我们写的Java程序其本质在**轮询每个Socket的时候也需要去调用`操作系统函数(windows:select,linux:epoll)`，轮询一次调用一次，会造成不必要的上下文切换开销。**
 *  而 **select()** 会将5个请求从`用户态空间` *全量复制*一份到`内核态空间`，在`内核态空间`来 **判断每个请求是否准备好数据**，`完全避免频繁的上下文切换`。所以*效率是比我们直接在`应用层写轮询`要高的。*
 *  如果**select()没有查询到到有数据的请求**，那么将会`一直阻塞`（是的，`select是一个阻塞函数`）。如果有一个或者多个请求已经准备好数据了，那么select()将会先将有数据的`文件描述符置位`，然后select()返回。返回后通过遍历查看哪个请求有数据。

**select的缺点：**

1.  底层存储依赖`BitMap`，处理的请求是有上限的，为`1024`。
2.  `文件描述符`是会`置位`的，所以如果当被`置位`的文件描述符需要重新使用时，是需要重新赋空值的。
3.  fd（文件描述符）从用户态拷贝到内核态仍然有一笔开销。
4.  select返回后还要再次遍历，来获知是哪一个请求有数据

--------------------

**poll函数底层逻辑**

*  poll的工作原理和select很像，先来看一段poll内部使用的一个结构体。
    
        struct pollfd{ 
        	int fd;
        	short events;
        	short revents;
        }
 *  `poll()`同样会将所有的请求`拷贝到内核态`，和select()一样，`poll同样是一个阻塞函数`，当一个或多个请求有数据的时候，也同样会进行`文件描述符置位`，但是它置位的是结构体`pollfd`中的`events`或者`revents置位`，而不是对`fd(文件描述符)`本身进行置位，所以在下一次使用的时候`不需要再进行重新赋空值`的操作。`poll内部存储不依赖bitmap`，而是使用`pollfd数组`的这样一个数据结构，数组的大小肯定是`大于1024`的。*解决了select`1、2`两点的缺点*。

--------------------

**epoll函数特点**

epoll是`最新的一种多路IO复用的函数`。这里只说说它的*特点*。

*  epoll和上述两个函数最大的不同是，它的`fd(文件描述符)是共享在用户态和内核态之间的`，所以可以`不必进行从用户态到内核态的一个拷贝`，这样可以 *节约系统资源*；另外，**在select()和poll()中，如果某个请求的数据已经准备好，它们会将所有的请求都返回，供程序去遍历查看哪个请求存在数据**，但是`epoll只会返回存在数据的请求`，这是因为**epoll在发现某个请求存在数据时，首先会进行一个`重排操作`，将所有有数据的`fd`放到最前面的位置，然后返回**（`返回值为存在数据请求的个数N`），*那么我们`应用层程序就可以不必将所有请求都轮询，而是·直接遍历epoll返回的前N个请求，这些请求都是有数据的请求`*。

### 2.3.Selector(选择器) ###

#### 2.3.1.概念 ####

**Selector 是Java NIO实现多路复用的基础。可以检查一个或多个NIO通道，并确定哪些通道已准备好进行读取或写入。实现单个线程可以管理多个通道，从而管理多个网络连接。**

*  Selector相当于一个`通道管理器`，不断轮询注册在其上的Channel，找出处于就绪状态，通过`SelectionKey`取得`就绪的Channel集合`，进行后续的IO操作。服务端只要提供一个`负责Selector轮询的线程即`可，实现**单线程中处理多个通道的目的，减少线程的创建数量**。
 *  channel对应一个`客户端请求`，数据的读写通过`buffer缓冲区`均在同一个channel中完成，并且**数据的读写是非阻塞的**。
 *  `通道channel创建后需要注册在selector中`，同时需要**为该通道注册相关事件（客户端连接服务端事件、服务端接收客户端连接事件、读事件、写事件）**，selector线程需要采用`轮询`的方式调用selector的`select函数`，直到所有注册通道中相关事件发生，则返回，否则一直阻塞。而后循环处理所有就绪的相关事件。
    
     *  select()函数: 这个方法会一直`阻塞到某个注册的通道有事件就绪`。一旦方法返回，线程就可以处理这些事件。

Java中使用Selector、Channel、Buffer来实现上述效果，如下图所示：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 24]

#### 2.3.2.Selector常用方法 ####

*  **Selector open()**：打开一个选择器。
 *  **Set keys()** 所有的 SelectionKey 集合。代表注册在该Selector上的Channel
 *  **selectedKeys()** 被选择的 SelectionKey 集合。返回此Selector的已选择键集
 *  **int select()** 监控所有注册的Channel，当它们中间有需要处理的 IO 操作时，该方法返回，并将对应得的 SelectionKey 加入被选择的  
    SelectionKey 集合中，该方法返回这些 Channel 的数量。
 *  **int select(long timeout)** 可以设置超时时长的 select() 操作
 *  **int selectNow()** 执行一个立即返回的 select() 操作，该方法不会阻塞线程
 *  **Selector wakeup()** 使一个还未返回的 select() 方法立即返回
 *  **void close()** 关闭该选择器

#### 2.3.3.使用Selector的步骤 ####

1.  创建 Selector ：通过调用`Selector.open()`方法创建一个 Selector
2.  向选择器注册通道：`SelectableChannel.register(Selector sel, int ops)`

**示例**

//通过调用Selector.open()方法创建一个Selector对象
     Selector selector = Selector.open();
    //设置通道为阻塞
     channel.configureBlocking(false);
    //注册Channel到Selector，并绑定读取事件
     SelectionKey key = channel.register(selector, Selectionkey.OP_READ);

> `Channel 必须是非阻塞的` 所以 FileChannel 不适用 Selector，`因为 FileChannel 不能切换为非阻塞模式`，更准确的来说是因为`FileChannel没有继承SelectableChannel`。SocketChannel可以正常使用。
> 
>  *  **判断一个通道能否被选择器监控或者选择，有一个前提：判断它`是否继承了抽象类SelectableChannel`。**

当调用`register(Selector sel, int ops)`将通道注册选择器时，选择器对通道的监听事件，需要通过第二个参数`ops`指定。可以监听的事件类型（ **可供Selector监控的通道IO事件类型，包括以下4种：**）：

*  Connect 连接（**SelectionKey.OP\_CONNET**）（ 8）
    
     *  某个Channel成功连接到另一个服务器称为 `连接就绪` 。
 *  Accept准备就绪（**SelectionKey.OP\_ACCEPT**） 16）
    
     *  一个ServerSocketChannel准备好接收新进入的连接称为 `接收就绪` 。
 *  Read读取（**SelectionKey.OP\_READ**）（ 1）
    
     *  一个有数据可读的通道可以说是 `读就绪`。
 *  Write写入（**SelectionKey.OP\_WRITE**)（ 4）
    
     *  等待写数据的通道可以说是`写就绪` 。

**若注册时不止监听一个事件，使用`位或运算符 连接`即可，如下：**

int interestSet = SelectionKey.OP_READ | SelectionKey.OP_WRITE;
    SelectionKey key = channel.register(selector,interestSet);

#### 2.3.4.SelectionKey的概念 ####

SelectionKey： 表示 SelectableChannel 和 Selector 之间的注册关系。每次向选择器注册通道时就会选择一个事件(选择键)。 选择键包含两个表示为整数值的操作集。操作集的每一位都表示该键的通道所支持的一类可选择操作。

*  SelectionKey 可以称为 `interest集合(兴趣集合)` 。 **意思是在通过Selector监听Channel时对什么事件感兴趣** 。`通道触发了一个事件意思是该事件已经就绪`。
    
    > 注：IO事件指的是通道的某个IO操作的一种就绪状态。

#### 2.3.5.SelectionKey的常用方法 ####

**一个SelectionKey表示了一个特定的通道对象和一个特定的选择器对象之间的注册关系，常用方法如下：**

*  **int interestOps()**：获取感兴趣事件集合
 *  **int readyOps()**：获取通道已经准备就绪的操作的集合
 *  **SelectableChannel channel()**：获取注册通道
 *  **Selector selector()** ：返回该SelectionKey对应的选择器
 *  **boolean isReadable()**： 检测 Channal 中读事件是否就绪
 *  **boolean isWritable()** ：检测 Channal 中写事件是否就绪
 *  **boolean isConnectable()**： 检测 Channel 中连接是否就绪
 *  **boolean isAcceptable()** ：检测 Channel 中接收是否就绪
 *  **interestOps()**：返回代表需要Selector监控的IO操作的bit mask
 *  **readyOps()**：返回一个bit mask，代表在相应channel上可以进行的IO操作
 *  **cancal()**：请求取消此键的通道到其选择器的注册。一旦返回，该键就是无效的，并且将被添加到其选择器的已取消键集中。在进行下一次选择操作时，将从所有选择器的键集中移除该键。
 *  **boolean isValid()**：检测此键是否有效。键在创建时是有效的，并在被取消、其通道已关闭或者其选择器已关闭之前保持有效。

#### 2.3.6.Selector的代码示例 ####

##### 1.NIO客户端-版本2 #####

public class NioClient2 { 
        private static SocketChannel socketChannel = null;
        private static int bufferSize = 1024;
        private static Selector selector;
        private static int port = 8080;
    
        public static void main(String[] args) throws IOException { 
            //打开通道
            socketChannel = SocketChannel.open();
            //打开选择器
            selector = Selector.open();
            //设置为非阻塞
            socketChannel.configureBlocking(false);
            //绑定事件
            socketChannel.register(selector, SelectionKey.OP_CONNECT);
            //请求服务路径
            socketChannel.connect(new InetSocketAddress(port));
            //具体操作
            connect();
        }
    
        public static void connect() throws IOException { 
            // 轮询访问selector
            while (true) { 
                //当注册的事件到达时,方法返回;否则将一直阻塞
                selector.select();
                // 获得selector中选中的项的迭代器
                Iterator<SelectionKey> ite = selector.selectedKeys().iterator();
                //循环处理注册事件
                /* 一共有四种事件: 1. 服务端接收客户端连接事件: SelectionKey.OP_ACCEPT 14 2. 客户端连接服务端事件: SelectionKey.OP_CONNECT 8 3. 读事件: SelectionKey.OP_READ 1 4. 写事件: SelectionKey.OP_WRITE 4 */
                while (ite.hasNext()) { 
                    SelectionKey key = ite.next();
                    //手动删除已选的key,以防重复处理
                    ite.remove();
                    //客户端连接事件就绪
                    if (key.isConnectable()) { 
                        //step1. 获取事件中的channel
                        SocketChannel channel = (SocketChannel) key.channel();
    
                        //step2. 如果正在连接,则等待完成连接
                        if (channel.isConnectionPending()) { 
                            channel.finishConnect();
                        }
                        //将连接设置为非阻塞
                        socketChannel.configureBlocking(false);
    
                        //step3. 连接后,客户端可以给服务端发送消息
                        channel.write(ByteBuffer.wrap("hello server".getBytes()));
                        //在和服务端连接成功之后，为了可以接收到服务端的信息，需要给通道设置读的权限。
                        channel.register(selector, SelectionKey.OP_READ);
                    }
    
                    //读事件就绪
                    if (key.isReadable()) { 
                        //step1. 获取事件中的channel
                        SocketChannel channel = (SocketChannel) key.channel();
    
                        ByteBuffer readBuffer = ByteBuffer.allocate(bufferSize);
                        //step2. 创建读取的缓冲区.将数据读取到缓冲区中
                        int readCount = channel.read(readBuffer);
                        String readText = new String(readBuffer.array(), 0, readCount);
                        System.out.println("读取的数据为：" + readText);
                        readBuffer.clear();
                        //客户端获取到服务端响应后,取消事件注册,断开连接
                        key.cancel();
                        socketChannel.close();
                        return;
                    }
                }
            }
        }
    }

##### 2.NIO服务端-版本3 #####

/** * NIO 同步非阻塞 该种方式 阻塞多路复用器 Selector 使用轮询方式查找是否存在io事件 * IO事件分为 OP_WRITE[缓冲区可以写入],OP_READ【缓存区有数据可读】,OP_CONNECT【客户端连接】,OP_ACCEPT[服务端接受到一个连接] */
    public class NioServer3 { 
        private static final int port = 8080;
        private static ServerSocketChannel serverSocketChannel = null;
        private static int bufferSize = 1024;
        private static Selector selector;
    
        public static void main(String[] args) throws IOException { 
            //打开通道
            serverSocketChannel = ServerSocketChannel.open();
            //设置为非阻塞
            serverSocketChannel.configureBlocking(false);
            //绑定端口
            serverSocketChannel.bind(new InetSocketAddress(port));
            //打开选择器
            selector = Selector.open();
            //通道注册到多路复用器 selector中 selector监听事件 接受客户端请求事件
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            //监听客户端
            listen();
        }
    
        public static void listen() throws IOException { 
            //存在注册的事件返回时 方法返回 否则一直阻塞 应该轮询
            while (true) { 
                selector.select();
                //select到了后面 说明存在事件 获取事件 并轮询
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectedKeys.iterator();
                while (iterator.hasNext()) { 
                    SelectionKey key = iterator.next();
                    iterator.remove();
    
                    //服务端接收客户端连接事件就绪
                    if (key.isAcceptable()) { 
                        //step1. 获取serverSocketChannel
                        ServerSocketChannel server = (ServerSocketChannel) key.channel();
    
                        //step2. 获得和客户端连接的socketChannel
                        SocketChannel channel = server.accept();
                        //设置客户端的通道为非阻塞
                        channel.configureBlocking(false);
    
                       ByteBuffer writeBuffer = ByteBuffer.allocate(bufferSize);//用完之后记得清理缓冲区缓存
                        //写入测试数据
                        writeBuffer.put("hello client".getBytes());
                        //step3. 连接后,客户端可以给服务端发送消息
                        channel.write(writeBuffer);
                        writeBuffer.clear();
    
                        //step4. 为了接收客户端的消息,注册读事件
                        channel.register(selector, SelectionKey.OP_READ);
                    }
    
                    //读数据就绪
                    if (key.isReadable()) { 
                        SocketChannel socketChannel = (SocketChannel) key.channel();
    
                        ByteBuffer readBuffer = ByteBuffer.allocate(bufferSize);//用完之后记得清理缓冲区缓存
                        //将客户端通道的数据读到缓存区
                        int readCount = socketChannel.read(readBuffer);
                        if (readCount > 0) { 
                            String readText = new String(readBuffer.array(), 0, readCount);
                            System.out.println("读取的数据为：" + readText);
                            readBuffer.clear();
                        }
                        else { 
                            System.out.println("客户端关闭");
                            key.cancel();
                            socketChannel.close();
                        }
                    }
                }
            }
        }
    }

## 4.BIO与NIO的区别 ##

*  使用BIO时往往会引入`多线程`，每个连接由一个单独的线程处理
 *  使用NIO则是使用`单线程`或者只使用`少量的多线程`，每个连接`共用`一个线程。
 *  NIO的最重要的地方是当一个连接创建后，不需要对应一个线程，这个连接会被注册到`多路复用器`上面，`所有的连接只需要一个线程就可以搞定`，当这个线程中的`多路复用器进行轮询`的时候，发现`连接上有请求`的话，才`开启一个线程进行处理`，也就是`一个请求一个线程模式`。
 *  在NIO的处理方式中，当一个请求来的话，开启线程进行处理，可能会等待后端应用的资源(JDBC连接等)，其实这个线程就被阻塞了，当并发上来的话，还是会有BIO一样的问题。

**~~~不过 Java 原生的 NIO 不好用，直到`Netty`的出现。**

# 四.Java中的AIO #

## 1.核心概念 ##

**AIO (Asynchronous I/O)，即 `异步非阻塞I/O`**

*  AIO 是`Java 1.7`的新特性，是 **NIO 的升级版本**，也被称作`NIO2.0`。提供了`异步非阻塞`的IO操作方式，所以人们叫它 `AIO（Asynchronous IO）`，异步 IO 是`基于事件和回调机制实现的`，也就是**应用操作之后会直接返回**，不会堵塞在那里，当后台处理完成，**`操作系统`会通知相应的线程进行后续的操作**。
    
     *  在`java.nio.channels包`下新增了`4个异步通道`：
        
         *  **AsynchronousFileChannel**：`异步文件通道`，用于文件数据的异步读写
         *  **AsynchronousSocketChannel**：异步套接字通道，用于TCP协议的数据异步读写
         *  **AsynchronousServerSocketChannel**：异步服务端套接字通道，用于监听TCP请求，为每个监听的请求创建一个AsynchronousSocketChannel套接字通道。
         *  **AsynchronousDatagramChannel**：异步数据包通道
 *  **服务器实现模式**为`一个有效请求一个线程`，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，

**那么什么叫做*异步非阻塞*？**

*  `异步非阻塞无需一个线程去轮询所有IO操作的状态改变`，*在相应的状态改变后，`系统os会通知对应的线程来处理`。* 对应到烧开水中就是，为每个水壶上面装了一个开关，水烧开之后，水壶会自动通知我水烧开了。
    
    > 老王觉得每隔一段时间就去看一看水壶太费劲了，于是购买了一批烧开水时可以`哔哔响`的水壶，于是开始烧水后，老王就直接去客厅玩手机了，水烧开时，就发出“哔哔”的响声，`通知老王来关掉水壶`。

**特点**

*  提供`异步文件通道`和`异步套接字通道`；
 *  其read，write方法的返回类型都是Future对象；
 *  而Future模型是异步的，其核心思想是：去主函数等待时间；
 *  基于事件和回调机制。
 *  **AIO 是向`操作系统注册 IO 监听`，操作系统完成 IO 操作了之后，主动通知，`触发响应的函数`（自己不做，让操作系统来做）。** 目前看，AIO 应用的还不是很广泛。

**与NIO不同区别**

*  当进行读写操作时，AIO只须直接`调用异步文件通道的的read或write`方法即可。这两种方法均为`异步`的，
 *  对于`读操作`而言，当有流可读取时，操作系统会将可读的流传入`read方法的缓冲区`，并`主动通知应用程序`；
 *  对于`写操作`而言，当操作系统将write方法传递的流写入完毕时，`操作系统主动通知应用程序`。
    
     *  即可以理解为，`read/write方法`都是异步的，`完成后会主动调用回调函数。`
 *  [NIO.2－异步通道组][NIO.2]

### 2.AIO的代码示例 ###

### 2.1.AsynchronousFileChannel ###

**在`Java7`中，AsynchronousFileChannel被添加到Java NIO中。 它可以`异步的从文件中读取数据并将数据写入文件`**

##### 通道获取 #####

**1.通过其静态方法open()打开一个通道**

Path path = Paths.get("/data/test.xml");
    AsynchronousFileChannel channel =  AsynchronousFileChannel.open(path, StandardOpenOption.READ);

*  第1个参数是指向`与AsynchronousFileChannel关联的文件的Path实例`。
 *  第2个参数是`打开通道的模式`, 可以设置一个或多个，告诉AsynchronousFileChannel在底层文件上执行什么操作。
    
     *  了解StandardOpenOption

##### 读取数据 #####

有2种方式读取数据。 我们可以调用它的`2个重载的 read() 方法`如下：

Future<Integer> read(ByteBuffer dst, long position);
    <A> void read(ByteBuffer dst,  long position,  A attachment, CompletionHandler<Integer,? super A> handler);

**1.通过Future来读取数据**

//获取AsynchronousFileChannel
    Path path = Paths.get("/data/test.xml");
    AsynchronousFileChannel fileChannel =  AsynchronousFileChannel.open(path, StandardOpenOption.READ);
    
    //通道数据写入缓冲区
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    long position = 0;
    Future<Integer> operation = fileChannel.read(buffer, position);
    
    //如果调用未完成就一直自旋
    while(!operation.isDone());
    
    //缓冲区切换为读数据模式
    buffer.flip();
    byte[] data = new byte[buffer.limit()];
    buffer.get(data);
    
    //输出结果
    System.out.println(new String(data));
    buffer.clear();

*  read()会返回一个Future实例
    
     *  **即使读操作没有完成，也会立即返回，可以通过调用`read()方法返回的Future实例的`isDone()方法来检查读取操作何时完成。**
 *  第1个参数为ByteBuffer。表示 从AsynchronousFileChannel读取的数据被读入这个ByteBuffer。
 *  第2个参数是文件中开始读取的字节位置。

**2.通过事件对象CompletionHandler读取数据**

第2种方法是调用`以CompletionHandler作为参数的read()`,以事件触发的形式获取要读去的数据。

fileChannel.read(buffer, position, buffer, new CompletionHandler<Integer, ByteBuffer>() { 
    	//一旦读取操作完成，CompletionHandler的completed（）方法将被调用
    	//result:有多少字节被读取，attachment：数据被读入的缓冲区
        @Override
        public void completed(Integer result, ByteBuffer attachment) { 
            System.out.println("result = " + result);
    		//切换为读取数据模式
            attachment.flip();
            //字节数据为本次缓冲区的读取长度
            byte[] data = new byte[attachment.limit()];
            //缓冲区数据读入字节数组
            attachment.get(data);
            System.out.println(new String(data));
            //清空缓冲区
            attachment.clear();
        }
    	
    	//读取操作失败
        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {   }
    });

*  第1个参数是个`Integer类型`，表示读取的字节数。
 *  第2个参数 attachment 是`ByteBuffer 类型的`，用来存储读取的数据。
 *  第3个参数就是`事件对象CompletionHandler`

##### 写入数据 #####

有2种方式写入数据。 我们可以调用它的`2个重载的 write()` 方法如下：

Future<Integer> write(ByteBuffer src, long position);
    <A> void write(ByteBuffer src, long position, A attachment, CompletionHandler<Integer,? super A> handler);

**1.通过 Future 写入数据**

//获取AsynchronousFileChannel
    Path path = Paths.get("data/test-write.txt");
    AsynchronousFileChannel fileChannel =   AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
    
    //数据写入缓冲区
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    long position = 0;
    buffer.put("test data".getBytes());
    //切换buffer的模式
    buffer.flip();
    
    //缓冲区写入通道，并清空缓存
    Future<Integer> operation = fileChannel.write(buffer, position);
    buffer.clear();
    
    //如果为完成就一直自旋
    while(!operation.isDone());
    
    //输出结果
    System.out.println("Write done");

> 注意，该文件必须已经存在。 如果文件不存在，write()将抛出一个`java.nio.file.NoSuchFileException异常`。

if(!Files.exists(path)){ 
        Files.createFile(path);
    }

**2.通过事件对象CompletionHandler 写入数据**  
第2种方法是调用将数据传入`以CompletionHandler作为参数的write()`,以事件触发的形式通知我们是否写入成功。

//文件不存在则创建文件,然后获取通道
    Path path = Paths.get("data/test-write.txt");
    if(!Files.exists(path)){ 
        Files.createFile(path);
    }
    AsynchronousFileChannel fileChannel =    AsynchronousFileChannel.open(path, StandardOpenOption.WRITE);
    
    //获取缓冲区并写入数据
    ByteBuffer buffer = ByteBuffer.allocate(1024);
    long position = 0;
    buffer.put("test data".getBytes());
    //切换缓冲区为读取数据
    buffer.flip();
    
    //写入数据
    fileChannel.write(buffer, position, buffer, new CompletionHandler<Integer, ByteBuffer>() { 
    	//数据写入完成的事件
        @Override
        public void completed(Integer result, ByteBuffer attachment) { 
            System.out.println("bytes written: " + result);
        }
    	//数据写入失败的事件 
        @Override
        public void failed(Throwable exc, ByteBuffer attachment) { 
            System.out.println("Write failed");
            exc.printStackTrace();
        }
    });

### 2.2.异步网络IO的代码示例 ###

服务端

public class AioServer { 
    	private static int port = 8080;
        private static AsynchronousServerSocketChannel serverSocketChannel = null;
        private static int bufferSize = 1024;
    
        public static void main(String[] args) throws IOException, InterruptedException { 
            serverSocketChannel = AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(port));
            serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() { 
    
                @Override
                public void completed(AsynchronousSocketChannel channel, Object attachment) { 
                    try { 
    
                        //读的异步
                        channel.read(readBuffer, null, new CompletionHandler<Integer, Object>() { 
    
                            @Override
                            public void completed(Integer result, Object attachment) { 
                                ByteBuffer readBuffer = ByteBuffer.allocate(bufferSize);
                                String readText = new String(readBuffer.array(), 0, result);
                                System.out.println("服务端读取的数据为：" + readText);
                                readBuffer.clear();
                            }
    
                            @Override
                            public void failed(Throwable exc, Object attachment) { 
                                exc.printStackTrace();
                                System.out.println("服务端读取数据失败");
                            }
    
                        });
    
    					ByteBuffer writeBuffer = ByteBuffer.allocate(bufferSize);
                        writeBuffer.put("hello client".getBytes());
                        writeBuffer.flip();
                        //写入测试数据
                        channel.write(writeBuffer);
    
                        // 监听新的请求，递归调用(开始下一次请求处理)
                        serverSocketChannel.accept(null, this);
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
    
                @Override
                public void failed(Throwable exc, Object attachment) { 
                    System.out.println("服务端出现异常：" + exc);
                    // 监听新的请求，递归调用(开始下一次请求处理)
                    serverSocketChannel.accept(null, this);
                }
    
            });
    
    
            //线程休眠,防止AsynchronousSocketChannel 是异步IO而导致主线程结束了
            Thread.sleep(1000 * 1000);
        }
    }

客户端

public class AioClient { 
        private static final int port = 8080;
        private static AsynchronousSocketChannel socketChannel = null;
        private static int bufferSize = 1024;
        private static Selector selector;
    
        public static void main(String[] args) throws Exception { 
            socketChannel = AsynchronousSocketChannel.open();
            //这里一定要指定ip 就算是本机 也要使用localhost
            socketChannel.connect(new InetSocketAddress("localhost", port), null, new CompletionHandler<Void, Object>() { 
    
                @Override
                public void completed(Void result, Object attachment) { 
                    try { 
                        //通过事件回调的方式读取服务端响应
                        socketChannel.read(readBuffer, null, new CompletionHandler<Integer, Object>() { 
                            //读取服务端数据成功
                            @Override
                            public void completed(Integer result, Object attachment) { 
                                ByteBuffer readBuffer = ByteBuffer.allocate(bufferSize);
                                String readText = new String(readBuffer.array(), 0, result);
                                System.out.println("客户端读取的数据为：" + readText);
                            }
    
                            //读取服务端数据失败
                            @Override
                            public void failed(Throwable exc, Object attachment) { 
                                exc.printStackTrace();
                                System.out.println("客户端读取数据失败");
                            }
    
                        });
    
        				ByteBuffer writeBuffer = ByteBuffer.allocate(bufferSize);
                        //写入数据到服务端
                        writeBuffer.put("hello server".getBytes());
                        writeBuffer.flip();
                        //写入测试数据
                        socketChannel.write(writeBuffer);
    
                    } catch (Exception e) { 
                        e.printStackTrace();
                    }
                }
    
                //读取客户端请求失败
                @Override
                public void failed(Throwable exc, Object attachment) { 
    				 System.out.println("客户端出现异常：" + exc);
                }
            });
    
            //线程休眠,防止AsynchronousSocketChannel 是异步IO而导致主线程结束了
            Thread.sleep(1000 * 1000);
        }
    }

先启动服务端，在启动客户端

服务端  
![在这里插入图片描述][2021062615005467.png]

客户端  
![在这里插入图片描述][20210626150109977.png]

# 五.适用场景 #

*  **BIO方式**： 适用于`连接数目比较小且固定的架构`，这种方式对服务器资源要求比较高，并发局限于应用中，`JDK1.4以前的唯一选择`，但程序直观简单易理解。
 *  **NIO方式**： 适用于`连接数目多且连接比较短（轻操作）的架构`，比如`聊天服务器`，并发局限于应用中，编程比较复杂，`JDK1.4开始支持`。
 *  **AIO方式**： 使用于`连接数目多且连接比较长（重操作）的架构`，比如`相册服务器`，充分调用OS参与并发操作，编程比较复杂，`JDK7开始支持`。

另外，`I/O属于底层操作`，需要`操作系统`支持，`并发也需要操作系统的支持`，所以`性能方面不同操作系统差异会比较明显`。

--------------------

参考文章  
[NIO学习笔记3][NIO_3]  
[NIO学习笔记4][NIO_4]  
[java网络编程几种IO模型的介绍和对比][java_IO]  
[ 以Java的视角来聊聊BIO、NIO与AIO的区别!][_Java_BIO_NIO_AIO]  
[深入理解Java三种IO模式和Epoll模型][Java_IO_Epoll]  
[Java基础：IO多路复用模型之select、poll、epoll][Java_IO_select_poll_epoll]  
[并发编程网 - ifeve.com-Java NIO系列教程][- ifeve.com-Java NIO]  
[IO多路复用及select、poll和epoll][IO_select_poll_epoll]  
[NIO多路复用机制][NIO]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210526150721161.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[Java_BIO_NIO_AIO]: https://blog.csdn.net/qq877728715/article/details/104499859
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20210617163516185.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[20210615175500954.png]: https://img-blog.csdnimg.cn/20210615175500954.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210617174409660.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[Linux]: https://www.cnblogs.com/shijiaqi1066/p/5749030.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20210617174426234.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[socket]: http://c.biancheng.net/view/2123.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20210627165207150.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20210628113841143.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[20200226143939537.png]: https://img-blog.csdnimg.cn/20200226143939537.png
[20200226115422900.png]: https://img-blog.csdnimg.cn/20200226115422900.png
[20200226144158516.png]: https://img-blog.csdnimg.cn/20200226144158516.png
[2]: https://img-blog.csdnimg.cn/20200226144320557.png
[3]: https://img-blog.csdnimg.cn/20200226144348780.png
[20200226144401312.png]: https://img-blog.csdnimg.cn/20200226144401312.png
[20200226144628528.png]: https://img-blog.csdnimg.cn/20200226144628528.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20200226144646963.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20200226115551863.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200226141502670.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 9]: https://img-blog.csdnimg.cn/20200226141652571.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 10]: https://img-blog.csdnimg.cn/20210604102127760.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 11]: https://img-blog.csdnimg.cn/2020022616524015.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 12]: https://img-blog.csdnimg.cn/20210628171323294.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 13]: https://img-blog.csdnimg.cn/2021062716245296.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 14]: https://img-blog.csdnimg.cn/20210627164358265.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 15]: https://img-blog.csdnimg.cn/2021062615295283.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 16]: https://img-blog.csdnimg.cn/20210627225106649.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 17]: https://img-blog.csdnimg.cn/20210627225329320.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 18]: https://img-blog.csdnimg.cn/20210701171819351.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 19]: https://img-blog.csdnimg.cn/20210701171754561.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 20]: https://img-blog.csdnimg.cn/20210701172726814.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 21]: https://img-blog.csdnimg.cn/20210701172621881.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[select_poll_epoll]: https://www.cnblogs.com/Anker/p/3265058.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 22]: https://img-blog.csdnimg.cn/20210604111944659.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 23]: https://img-blog.csdnimg.cn/2020022615405624.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1_size_16_color_FFFFFF_t_70 24]: https://img-blog.csdnimg.cn/20210625162623246.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxODc3NzI4NzE1,size_16,color_FFFFFF,t_70
[NIO.2]: https://www.jianshu.com/p/0a19864c8597
[2021062615005467.png]: https://img-blog.csdnimg.cn/2021062615005467.png
[20210626150109977.png]: https://img-blog.csdnimg.cn/20210626150109977.png
[NIO_3]: https://blog.csdn.net/qq_15351029/article/details/106747167
[NIO_4]: https://blog.csdn.net/qq_15351029/article/details/106774862
[java_IO]: https://blog.csdn.net/elricboa/article/details/79034617
[_Java_BIO_NIO_AIO]: http://blog.itpub.net/31559927/viewspace-2218749/
[Java_IO_Epoll]: https://blog.csdn.net/hao134838/article/details/113185058
[Java_IO_select_poll_epoll]: https://www.pianshen.com/article/2970333871/
[- ifeve.com-Java NIO]: http://ifeve.com/overview/
[IO_select_poll_epoll]: https://lovelybear.blog.csdn.net/article/details/84710438
[NIO]: https://blog.csdn.net/mikewuhao/article/details/106915576?spm=1001.2014.3001.5501