同步异步阻塞非阻塞可参考IO 与 NIO
- Java NIO 全称 Java non-blocking IO ，是指 JDK 提供的新 API。从 JDK1.4 开始，Java 提供了一系列改进的输入/输出的新特性，被统称为 NIO（即 NewIO），是同步非阻塞的。
- NIO 相关类都被放在 java.nio 包及子包下，并且对原 java.io 包中的很多类进行改写。【基本案例】
- NIO 有三大核心部分: Channel（通道）、Buffer（缓冲区）、Selector（选择器） 。
- NIO 是面向缓冲区，或者面向块编程的。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动，这就增加了处理过程中的灵活性，使用它可以提供非阻塞式的高伸缩性网络。
- Java NIO 的非阻塞模式，使一个线程从某通道发送请求或者读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞（BIO就会阻塞），所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此，一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。【后面有案例说明】
- 通俗理解：NIO 是可以做到用一个线程来处理多个 *** 作的。假设有 10000 个请求过来,根据实际情况，可以分配 50 或者 100 个线程来处理。不像之前的阻塞 IO 那样，非得分配 10000 个。
- HTTP 2.0 使用了多路复用的技术，做到同一个连接并发处理多个请求，而且并发请求的数量比 HTTP 1.1 大了好几个数量级。
- 案例说明 NIO 的 Buffer
package com.atguigu.nio;
import java.nio.IntBuffer;
public class BasicBuffer {
public static void main(String[] args) {
//举例说明 Buffer 的使用(简单说明)
//创建一个 Buffer，大小为 5，即可以存放 5 个 int
IntBuffer intBuffer = IntBuffer.allocate(5);
//向buffer存放数据
//intBuffer.put(10);
//intBuffer.put(11);
//intBuffer.put(12);
//intBuffer.put(13);
//intBuffer.put(14);
for (int i = 0; i < intBuffer.capacity(); i++) {
intBuffer.put(i * 2);
}
//如何从 buffer 读取数据
//将 buffer 转换，读写切换(!!!)
intBuffer.flip();
while (intBuffer.hasRemaining()) {
System.out.println(intBuffer.get());
}
}
}
- BIO 以流的方式处理数据，而 NIO 以块的方式处理数据，块 I/O 的效率比流 I/O 高很多。
- BIO 是阻塞的，NIO 则是非阻塞的。
- BIO 基于字节流和字符流进行 *** 作，而 NIO 基于 Channel（通道）和 Buffer（缓冲区）进行 *** 作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector（选择器）用于监听多个通道的事件（比如：连接请求，数据到达等），因此使用单个线程就可以监听多个客户端通道。
一张图描述 NIO 的 Selector、Channel 和 Buffer 的关系。
1.3.1 Selector、Channel 和 Buffer 关系图（简单版）关系图的说明:
- **每个 **Channel 都会对应一个 Buffer。
- Selector 对应一个线程，一个线程对应多个 Channel（连接）。
- 该图反应了有三个 Channel 注册到该 Selector //程序
- 程序切换到哪个 Channel 是由事件决定的，Event 就是一个重要的概念。
- Selector 会根据不同的事件，在各个通道上切换。
- Buffer 就是一个内存块，底层是有一个数组。
- 数据的读取写入是通过 Buffer，这个和 BIO不同，BIO 中要么是输入流，或者是输出流，不能双向，但是 NIO 的 Buffer 是可以读也可以写，需要 flip 方法切换 Channel 是双向的，可以返回底层 *** 作系统的情况，比如 Linux，底层的 *** 作系统通道就是双向的。
缓冲区（Buffer）：缓冲区本质上是一个可以读写数据的内存块，可以理解成是一个容器对象（含数组），该对象提供了一组方法，可以更轻松地使用内存块，，缓冲区对象内置了一些机制，能够跟踪和记录缓冲区的状态变化情况。Channel 提供从文件、网络读取数据的渠道，但是读取或写入的数据都必须经由 Buffer，如图:【后面举例说明】
- 在 NIO 中，Buffer 是一个顶层父类，它是一个抽象类，类的层级关系图：
- Buffer 类定义了所有的缓冲区都具有的四个属性来提供关于其所包含的数据元素的信息：
三个属性的具体意义可参考：ByteBuffer 的position,limit,capacity ，limit在读写切换的时候会置为当前缓存中数据的最后一个位置。
flip的时候会把limit置为postion，clear的时候会把limit置为capacity
- Buffer 类相关方法一览
从前面可以看出对于 Java 中的基本数据类型（boolean 除外），都有一个 Buffer 类型与之相对应，最常用的自然是 ByteBuffer 类（二进制数据），该类的主要方法如下：
- NIO 的通道类似于流，但有些区别如下：
- 通道可以同时进行读写，而流只能读或者只能写
- 通道可以实现异步读写数据
- 通道可以从缓冲读数据，也可以写数据到缓冲:
- BIO 中的 Stream 是单向的，例如 FileInputStream 对象只能进行读取数据的 *** 作，而 NIO 中的通道（Channel）是双向的，可以读 *** 作，也可以写 *** 作。
- Channel 在 NIO 中是一个接口 public interface Channel extends Closeable{}
- 常用的 Channel 类有：FileChannel、DatagramChannel、ServerSocketChannel 和 SocketChannel。【ServerSocketChanne 类似 ServerSocket、SocketChannel 类似 Socket】
- FileChannel 用于文件的数据读写，DatagramChannel 用于 UDP 的数据读写，ServerSocketChannel 和 SocketChannel 用于 TCP 的数据读写。
- 图示
FileChannel 主要用来对本地文件进行 IO *** 作，常见的方法有
- public int read(ByteBuffer dst)，从通道读取数据并放到缓冲区中
- public int write(ByteBuffer src)，把缓冲区的数据写到通道中
- public long transferFrom(ReadableByteChannel src, long position, long count)，从目标通道中复制数据到当前通道
- public long transferTo(long position, long count, WritableByteChannel target)，把数据从当前通道复制给目标通道
实例要求：
- 使用前面学习后的 ByteBuffer（缓冲）和 FileChannel（通道），将 “hello,尚硅谷” 写入到 file01.txt 中
- 文件不存在就创建
package com.atguigu.nio;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class NIOFileChannel01 {
public static void main(String[] args) throws Exception {
String str = "hello,尚硅谷";
//创建一个输出流 -> channel
FileOutputStream fileOutputStream = new FileOutputStream("d:\file01.txt");
//通过 fileOutputStream 获取对应的 FileChannel
//这个 fileChannel 真实类型是 FileChannelImpl
FileChannel fileChannel = fileOutputStream.getChannel();
//创建一个缓冲区 ByteBuffer
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
//将 str 放入 byteBuffer
byteBuffer.put(str.getBytes());
//对 byteBuffer 进行 flip
byteBuffer.flip();
//利用fileChannel将 byteBuffer 数据写到文件中
fileChannel.write(byteBuffer);
fileOutputStream.close();
}
}
实例要求：
- 使用前面学习后的 ByteBuffer（缓冲）和 FileChannel（通道），将 file01.txt 中的数据读入到程序，并显示在控制台屏幕
- 假定文件已经存在
package com.atguigu.nio;
import java.io.File;
import java.io.FileInputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class NIOFileChannel02 {
public static void main(String[] args) throws Exception {
//创建文件的输入流
File file = new File("d:\file01.txt");
FileInputStream fileInputStream = new FileInputStream(file);
//通过 fileInputStream 获取对应的 FileChannel -> 实际类型 FileChannelImpl
FileChannel fileChannel = fileInputStream.getChannel();
//创建缓冲区
ByteBuffer byteBuffer = ByteBuffer.allocate((int)file.length());
//将通道的数据读入到 Buffer
fileChannel.read(byteBuffer);
//将 byteBuffer 的字节数据转成 String
System.out.println(new String(byteBuffer.array()));
fileInputStream.close();
}
}
实例要求：
- 使用 FileChannel（通道）和方法 read、write，完成文件的拷贝
- 拷贝一个文本文件 1.txt，放在项目下即可
- 代码演示
package com.atguigu.nio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class NIOFileChannel03 {
public static void main(String[] args) throws Exception {
FileInputStream fileInputStream = new FileInputStream("1.txt");
FileChannel fileChannel01 = fileInputStream.getChannel();
FileOutputStream fileOutputStream = new FileOutputStream("2.txt");
FileChannel fileChannel02 = fileOutputStream.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate(512);
while (true) { //循环读取
//这里有一个重要的 *** 作，一定不要忘了
/*
public final Buffer clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
*/
//因为将buffer数据写到channel后limit=postion,此时再读取buffer的话read为0，就会一直循环
byteBuffer.clear(); //必须要清空 buffer postion归0
int read = fileChannel01.read(byteBuffer);
System.out.println("read = " + read);
if (read == -1) { //表示读完
break;
}
//将 buffer 中的数据写入到 fileChannel02--2.txt
byteBuffer.flip();
fileChannel02.write(byteBuffer);
}
//关闭相关的流
fileInputStream.close();
fileOutputStream.close();
}
}
上面这三个例子，只要记住channel是用过buffer来读写数据就能区分清楚是用read还是write
3.6.5 应用实例4 - 拷贝文件 transferFrom 方法- 实例要求：
- 使用 FileChannel（通道）和方法 transferFrom，完成文件的拷贝
- 拷贝一张图片
package com.atguigu.nio;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.channels.FileChannel;
public class NIOFileChannel04 {
public static void main(String[] args) throws Exception {
//创建相关流
FileInputStream fileInputStream = new FileInputStream("d:\a.jpg");
FileOutputStream fileOutputStream = new FileOutputStream("d:\a2.jpg");
//获取各个流对应的 FileChannel
FileChannel sourceCh = fileInputStream.getChannel();
FileChannel destCh = fileOutputStream.getChannel();
//使用 transferForm 完成拷贝
destCh.transferFrom(sourceCh, 0, sourceCh.size());
//关闭相关通道和流
sourceCh.close();
destCh.close();
fileInputStream.close();
fileOutputStream.close();
}
}
-
ByteBuffer 支持类型化的 put 和 get，put 放入的是什么数据类型，get 就应该使用相应的数据类型来取出，否则可能有 BufferUnderflowException 异常。
注：这里翻看源码抛异常的原因是postion>limit，buffer存放完数据调用flip后，limit变为16（存放数据最后一位），读取时int,long不同类型会移动相应的postion，超出了limit就会报错。
【举例说明】
package com.atguigu.nio;
import java.nio.ByteBuffer;
public class NIOByteBufferPutGet {
public static void main(String[] args) {
//创建一个 Buffer
ByteBuffer buffer = ByteBuffer.allocate(64);
//类型化方式放入数据
buffer.putInt(100);
buffer.putLong(9);
buffer.putChar('尚');
buffer.putShort((short) 4);
//取出
buffer.flip();
System.out.println();
System.out.println(buffer.getInt());
System.out.println(buffer.getLong());
System.out.println(buffer.getChar());
System.out.println(buffer.getShort());
}
}
- 可以将一个普通 Buffer 转成只读 Buffer【举例说明】
package com.atguigu.nio;
import java.nio.ByteBuffer;
public class ReadOnlyBuffer {
public static void main(String[] args) {
//创建一个 buffer
ByteBuffer buffer = ByteBuffer.allocate(64);
for (int i = 0; i < 64; i++) {
buffer.put((byte) i);
}
//读取
buffer.flip();
//得到一个只读的 Buffer
ByteBuffer readOnlyBuffer = buffer.asReadOnlyBuffer();
System.out.println(readOnlyBuffer.getClass());
//读取
while (readOnlyBuffer.hasRemaining()) {
System.out.println(readOnlyBuffer.get());
}
readOnlyBuffer.put((byte) 100); //ReadOnlyBufferException
}
}
- NIO 还提供了 MappedByteBuffer，可以让文件直接在内存（堆外的内存）中进行修改，而如何同步到文件由 NIO 来完成。【举例说明】
package com.atguigu.nio;
import java.io.RandomAccessFile;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
/**
* 说明 1.MappedByteBuffer 可让文件直接在内存（堆外内存）修改, *** 作系统不需要拷贝一次
*/
public class MappedByteBufferTest {
public static void main(String[] args) throws Exception {
RandomAccessFile randomAccessFile = new RandomAccessFile("1.txt", "rw");
//获取对应的通道
FileChannel channel = randomAccessFile.getChannel();
/**
* 参数 1:FileChannel.MapMode.READ_WRITE 使用的读写模式
* 参数 2：0：可以直接修改的起始位置
* 参数 3:5: 是映射到内存的大小（不是索引位置），即将 1.txt 的多少个字节映射到内存
* 可以直接修改的范围就是 0-5
* 实际类型 DirectByteBuffer
*/
MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 5);
mappedByteBuffer.put(0, (byte) 'H');
mappedByteBuffer.put(3, (byte) '9');
mappedByteBuffer.put(5, (byte) 'Y');//IndexOutOfBoundsException
randomAccessFile.close();
System.out.println("修改成功~~");
}
}
- 前面我们讲的读写 *** 作，都是通过一个 Buffer 完成的，NIO 还支持通过多个 Buffer（即 Buffer数组）完成读写 *** 作，即 Scattering 和 Gathering【举例说明】
package com.atguigu.nio;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Arrays;
/**
* Scattering：将数据写入到 buffer 时，可以采用 buffer 数组，依次写入 [分散]
* Gathering：从 buffer 读取数据时，可以采用 buffer 数组，依次读
*/
public class ScatteringAndGatheringTest {
public static void main(String[] args) throws Exception {
//使用 ServerSocketChannel 和 SocketChannel 网络
ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
InetSocketAddress inetSocketAddress = new InetSocketAddress(7000);
//绑定端口到 socket，并启动
serverSocketChannel.socket().bind(inetSocketAddress);
//创建 buffer 数组
ByteBuffer[] byteBuffers = new ByteBuffer[2];
byteBuffers[0] = ByteBuffer.allocate(5);
byteBuffers[1] = ByteBuffer.allocate(3);
//等客户端连接 (telnet)
SocketChannel socketChannel = serverSocketChannel.accept();
int messageLength = 8; //假定从客户端接收 8 个字节
//循环的读取
while (true) {
int byteRead = 0;
while (byteRead < messageLength) {
long l = socketChannel.read(byteBuffers);
byteRead += l; //累计读取的字节数
System.out.println("byteRead = " + byteRead);
//使用流打印,看看当前的这个 buffer 的 position 和 limit
Arrays.asList(byteBuffers).stream().map(buffer -> "position = " + buffer.position() + ", limit = " + buffer.limit()).forEach(System.out::println);
}
//将所有的 buffer 进行 flip
Arrays.asList(byteBuffers).forEach(buffer -> buffer.flip());
//将数据读出显示到客户端
long byteWirte = 0;
while (byteWirte < messageLength) {
long l = socketChannel.write(byteBuffers);//
byteWirte += l;
}
//将所有的buffer进行clear
Arrays.asList(byteBuffers).forEach(buffer -> {
buffer.clear();
});
System.out.println("byteRead = " + byteRead + ", byteWrite = " + byteWirte + ", messagelength = " + messageLength);
}
}
}
- Java 的 NIO，用非阻塞的 IO 方式。可以用一个线程，处理多个的客户端连接，就会使用到 Selector（选择器）。
- Selector 能够检测多个注册的通道上是否有事件发生（注意：多个 Channel 以事件的方式可以注册到同一个 Selector），如果有事件发生，便获取事件然后针对每个事件进行相应的处理。这样就可以只用一个单线程去管理多个通道，也就是管理多个连接和请求。【示意图】
- 只有在连接/通道真正有读写事件发生时，才会进行读写，就大大地减少了系统开销，并且不必为每个连接都创建一个线程，不用去维护多个线程。
- 避免了多线程之间的上下文切换导致的开销。
说明如下：
- Netty 的 IO 线程 NioEventLoop 聚合了 Selector（选择器，也叫多路复用器），可以同时并发处理成百上千个客户端连接。
- 当线程从某客户端 Socket 通道进行读写数据时，若没有数据可用时，该线程可以进行其他任务。
- 线程通常将非阻塞 IO 的空闲时间用于在其他通道上执行 IO *** 作，所以单独的线程可以管理多个输入和输出通道。
- 由于读写 *** 作都是非阻塞的，这就可以充分提升 IO 线程的运行效率，避免由于频繁 I/O 阻塞导致的线程挂起。
- 一个 I/O 线程可以并发处理 N 个客户端连接和读写 *** 作，这从根本上解决了传统同步阻塞 I/O 一连接一线程模型，架构的性能、d性伸缩能力和可靠性都得到了极大的提升。
- NIO 中的 ServerSocketChannel 功能类似 ServerSocket、SocketChannel 功能类似 Socket。
- Selector 相关方法说明
- selector.select(); //阻塞
- selector.select(1000); //阻塞 1000 毫秒，在 1000 毫秒后返回
- selector.wakeup(); //唤醒 selector
- selector.selectNow(); //不阻塞，立马返还
可以发现NIO中的selector的select等方法还是会阻塞的，NIO中的not blocking指的是在读取channel数据时不会因为没有数据而阻塞。
1.7.5补充select和epoll可参考：深入理解select、poll和epoll及区别
目前支持I/O多路复用的系统调用有select/pselect/poll/epoll。
select的实现思路很直接。有两个队列：等待队列(每个socket都有)、工作队列。
假如程序同时监视如下图的sock1、sock2和sock3三个socket，那么在调用select之后， *** 作系统把进程A分别加入这三个socket的等待队列中。
当任何一个socket收到数据后，中断程序将唤起进程。下图展示了sock2接收到了数据的处理流程。
所谓唤起进程，就是将进程从所有的等待队列中移除，加入到工作队列里面。如下图所示。
经由这些步骤，当进程A被唤醒后，它知道至少有一个socket接收了数据。程序只需遍历一遍socket列表，就可以得到就绪的socket。
这种简单方式行之有效，在几乎所有 *** 作系统都有对应的实现。
但是简单的方法往往有缺点，主要是：
- 其一，每次调用select都需要将进程加入到所有监视socket的等待队列，每次唤醒都需要从每个队列中移除。这里涉及了两次遍历（遍历所有socket和遍历socket的等待队列），而且每次都要将整个fds列表传递给内核，有一定的开销。正是因为遍历 *** 作开销大，出于效率的考量，才会规定select的最大监视数量，默认只能监视1024个socket。
- 其二，进程被唤醒后（一是唤醒时），程序并不知道哪些socket收到数据，还需要遍历一次。
那么，有没有减少遍历的方法？有没有保存就绪socket的方法？这两个问题便是epoll技术要解决的。
这里只解释了select的一种情形。 当程序调用select时，内核会先遍历一遍socket，如果有一个以上的socket接收缓冲区有数据，那么select直接返回，不会阻塞。 这也是为什么select的返回值有可能大于1的原因之一。 如果没有socket有数据，进程才会阻塞（select方法阻塞）。
select低效的原因之一是将“维护等待队列”和“阻塞进程”两个步骤合二为一。如下图所示，每次调用select都需要这两步 *** 作，然而大多数应用场景中，需要监视的socket相对固定，并不需要每次都修改。epoll将这两个 *** 作分开，先用epoll_ctl维护等待队列，再调用epoll_wait阻塞进程。显而易见的，效率就能得到提升（epoll第一次调用的时候维护一次等待队列后就无需再修改）。
select低效的另一个原因在于程序不知道哪些socket收到数据，只能一个个遍历。如果内核维护一个“就绪列表”，引用收到数据的socket，就能避免遍历。如下图所示，计算机共有三个socket，收到数据的sock2和sock3被rdlist（就绪列表）所引用。当进程被唤醒后，只要获取rdlist的内容，就能够知道哪些socket收到数据。
epoll是在select出现N多年后才被发明的，是select和poll的增强版本。epoll通过以下一些措施来改进效率。（多了就绪队列，在eventpoll对象上）
原理：
1.创建epoll对象
如下图所示，当某个进程调用epoll_create方法时，内核会创建一个eventpoll对象（也就是程序中epfd所代表的对象，file description）。eventpoll对象也是文件系统中的一员，和socket一样，它也会有等待队列。
创建一个代表该epoll的eventpoll对象是必须的，因为内核要维护“就绪列表”等数据，“就绪列表”可以作为eventpoll的成员。
2.维护监视列表
创建epoll对象后，可以用epoll_ctl添加或删除所要监听的socket。以添加socket为例，如下图，如果通过epoll_ctl添加sock1、sock2和sock3的监视，内核会将eventpoll添加到这三个socket的等待队列中。
当socket收到数据后，中断程序会 *** 作eventpoll对象，而不是直接 *** 作进程。
3.接收数据
当socket收到数据后，中断程序会给eventpoll的“就绪列表”添加socket引用。如下图展示的是sock2和sock3收到数据后，中断程序让rdlist引用这两个socket。
eventpoll对象相当于是socket和进程之间的中介，socket的数据接收并不直接影响进程，而是通过改变eventpoll的就绪列表来改变进程状态（相比select是把进程对象放在socket的等待队列中)。
当程序执行到epoll_wait时，如果rdlist已经引用了socket，那么epoll_wait直接返回，如果rdlist为空，阻塞进程。
4.阻塞和唤醒进程
假设计算机中正在运行进程A和进程B，在某时刻进程A运行到了epoll_wait语句。如下图所示，内核会将进程A放入eventpoll的等待队列中，阻塞进程。
当socket接收到数据，中断程序一方面修改rdlist，另一方面唤醒eventpoll等待队列中的进程，进程A再次进入运行状态（如下图）。也因为rdlist的存在，进程A可以知道哪些socket发生了变化。
总的来说，select与epoll的区别：
- epoll一个进程打开的fd不受限，select默认1024
- epoll的I/O效率不会随FD增加而下降，select因为每次都要遍历所有socket，所以性能会下降，O(n)
- epoll还使用了mmp提高了内核与用户空间信息传递的速度。
- epoll的API更简单。
java的nio代码会根据 *** 作系统选择epoll或者poll
1.8 NIO 非阻塞网络编程原理分析图NIO 非阻塞网络编程相关的（Selector、SelectionKey、ServerScoketChannel 和 SocketChannel）关系梳理图
对上图的说明：
- 当客户端连接时，会通过 ServerSocketChannel 得到 SocketChannel。
- Selector 进行监听 select 方法，返回有事件发生的通道的个数。
- 将 socketChannel 注册到 Selector 上，register(Selector sel, int ops)，一个 Selector 上可以注册多个 SocketChannel。
- 注册后返回一个 SelectionKey，会和该 Selector 关联（集合）。
- 进一步得到各个 SelectionKey（有事件发的）。
- 在通过 SelectionKey 反向获取 SocketChannel，方法 channel()。
- 可以通过得到的 channel，完成业务处理。
- JDK7 引入了 AsynchronousI/O，即 AIO。在进行 I/O 编程中，常用到两种模式：Reactor 和 Proactor。Java 的 NIO 就是 Reactor，当有事件触发时，服务器端得到通知，进行相应的处理
- AIO 即 NIO2.0，叫做异步不阻塞的 IO。AIO 引入异步通道的概念，采用了 Proactor 模式，简化了程序编写，有效的请求才启动线程**，它的特点是先由 *** 作系统完成后才通知服务端程序启动线程去处理（应用进程不参与，等 *** 作系统完成后再通知应用进程，参考3.16中的示意图）**，一般适用于连接数较多且连接时间较长的应用
- 目前 AIO 还没有广泛应用，Netty 也是基于 NIO，而不是 AIO，因此我们就不详解 AIO 了，有兴趣的同学可以参考《Java新一代网络编程模型AIO原理及Linux系统AIO介绍》
| BIO | NIO | AIO | |
|---|---|---|---|
| IO模型 | 同步阻塞 | 同步非阻塞（多路复用） | 异步非阻塞 |
| 编程难度 | 简单 | 复杂 | 复杂 |
| 可靠性 | 差 | 好 | 好 |
| 吞吐量 | 低 | 高 | 高 |
阻塞 / 非阻塞描述的是函数，指访问某个函数时是否会阻塞线程(block，线程进入阻塞状态)。
同步 /异步描述的是执行IO *** 作的主体是谁，同步是由用户进程自己去执行最终的IO *** 作。异步是用户进程自己不关系实际IO *** 作的过程，只需要由内核在IO完成后通知它既可，由内核进程来执行最终的IO *** 作。
非阻塞同步IO指的是用户调用读写方法是不阻塞的，立刻返回的，而且需要用户线程来检查IO状态。需要注意的是，如果发现有可以 *** 作的IO，那么实际用户进程还是会阻塞等待内核复制数据到用户进程，它与同步阻塞IO的区别是后者全程等待。
非阻塞异步IO指的是用户调用读写方法是不阻塞的，立刻返回，而且用户不需要关注读写，只需要提供回调 *** 作，内核线程在完成读写后回调用户提供的callback。
详细的参考：netty到底是同步还是异步？ - bin的技术小屋的回答 - 知乎
注：笔记整理自韩顺平老师 Netty 课程《尚硅谷 Netty 视频教程》，迁移自自己语雀文档。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）