1. IO分类概述
1.1 阻塞与非阻塞
阻塞（Blocking）和非阻塞（Nonblocking）是在计算机编程中用于描述I/O操作的两个重要概念。阻塞与非阻塞描述的是线程在访问某个资源时，在该资源没有准备就绪期间的处理方式。
1、阻塞：阻塞是指在进行I/O操作时，当前线程会被挂起，等待数据的就绪或操作的完成。
- 在阻塞状态下，线程会一直等待，直到条件满足或超时才会继续执行
- 阻塞式I/O操作会导致调用线程无法执行其他任务，直到I/O操作完
- 例如，在读取文件时，如果没有数据可用，线程会一直等待直到有数据可读
2、非阻塞：非阻塞是指进行I/O操作时，当前线程不会被挂起，而是立即返回并继续执行其他任务。
- 在非阻塞状态下，即使I/O操作无法立即完成，线程也可以继续执行其他操作，而不需要一直等待
- 非阻塞式I/O操作通常会返回一个状态或错误码，指示操作是否完成或需要进一步处理
- 应用程序可以通过不断轮询状态来判断是否可以进行下一步操作
1.2 同步与异步
同步（synchronous）与异步（asynchronous）描述的是线程在发出请求后，是否等待结果。
1、同步（Synchronous）：同步是指程序按照顺序执行，并等待某个操作完成后再继续执行下一个操作。
- 在同步操作中，程序主动发起请求并等待结果返回，直到结果返回后才能继续执行后续操作
- 同步操作通常是阻塞的，即在等待结果时当前线程会被挂起，无法执行其他任务
- 典型的同步操作包括函数调用、阻塞式I/O操作等
2、异步（Asynchronous）：异步是指程序在发起某个操作后，不需要立即等待操作完成，而是继续执行后续的操作。
- 在异步操作中，程序不会阻塞等待结果的返回，而是通过回调、轮询或事件通知等机制来获取结果或处理完成的事件
- 异步操作允许程序并发执行多个任务，提高了系统的并发性和响应性。典型的异步操作包括异步函数调用、非阻塞式I/O操作、异步任务等
1.3 IO的分类
当涉及I/O操作时，可以根据是否阻塞和是否异步的角度将其分为以下四类：
1、阻塞式I/O（Blocking I/O）
- 特点：在进行I/O操作时，当前线程会被阻塞，直到数据就绪或操作完成
- 工作原理：当进行I/O操作时，线程会等待直到数据准备好或操作完成，在等待期间，线程无法执行其他任务
2、非阻塞式I/O（Non-Blocking I/O）
- 特点：进行I/O操作时，当前线程不会被阻塞，立即返回并继续执行其他任务
- 工作原理：当进行I/O操作时，如果数据尚未准备好或操作无法立即完成，操作会立即返回一个状态指示暂时不可用
3、I/O多路复用（I/O Multiplexing）
- 特点：允许一个线程同时监视多个I/O通道的就绪状态，提高了系统的并发性能
- 工作原理：通过操作系统提供的I/O复用机制，将多个I/O通道注册到一个选择器上，然后使用选择器进行轮询以确定哪些通道就绪
4、异步I/O（Asynchronous I/O）
- 特点：在进行I/O操作时，不需要立即等待操作完成，可以继续执行其他任务，通过回调或事件机制来处理操作结果
- 工作原理：应用程序提交I/O请求后立即返回，并使用回调、轮询或事件通知等方式来处理操作完成的通知
这四种I/O模型各有优劣，并适用于不同的应用场景：
- 阻塞式I/O适用于简单的同步操作
- 非阻塞式I/O适用于需要处理多个连接的场景
- I/O多路复用适用于需要监视多个连接的场景
- 异步I/O适用于需要高性能和扩展性的场景
根据具体的应用需求和系统特点，可以选择合适的I/O模型来实现高效的数据传输和处理。
2. Java NIO
2.1 Java NIO概述
在Java编程中，经常听到BIO，NIO，AIO等名词，这些名词一般指的是Java语言为实现不同类型的I/O操作所提供的API。
1、Java IO：Java IO是JDK 1.0版本其自带的用于读取和写入数据的API。因其同步、阻塞的特征，被归类为同步阻塞式IO（Blocking IO），即Java BIO。
2、Java NIO（New IO）：是JDK 1.4开始提供的同步非阻塞式的IO操作API。因其同步、非阻塞的特征，开发者一般将Java NIO理解为Java Non-Blocking IO。
3、Java NIO 2.0：是JDK 1.7开始提供的异步非阻塞式的IO操作API，因其是在NIO的基础上进行了改进，称为NIO 2.0。因其异步、非阻塞的特征，开发者一般将Java NIO 2.0称为Java AIO。
下面以一个Web服务器的例子介绍Java BIO和Java NIO在实际使用中的差别。
基于BIO的场景：
基于NIO的场景：
2.2 Java BIO模型
Java BIO和NIO采用了2种不同的模型。BIO使用了面向流（Stream Oriented）的模型。流（Stream）可以理解为从源节点到目标节点的数据通道，传输的数据像水流一样从源节点流向目标节点。
面向流的特点：
- 单向的：一个流中的数据仅能从一个方向流向另一个方向
- 面向字节的：程序每次可以从流中读取1到多个字节，或写入1到多个字节
- 无缓冲的：从流中读取数据后，流中的数据消失
- 顺序访问：仅能按顺序逐个访问流中的数据，不能在流中的数据中前后移动
2.3 Java NIO模型
Java NIO使用了面向缓冲区（Buffer Oriented）的，基于通道（Channel Based）的模型。模型的不同使得BIO和NIO在功能上和操作上有着不同的特点。
在面向缓冲的模型中，数据通过数据通道（Channel）被读入/写入到一个缓冲区（Buffer）中，然后从中进行处理。
可以使用一个生活中的例子来理解：现在需要从房间A搬运一些纸质文件到房间B，房间A和房间B之间通过一个走廊相连。搬运文件时，先将文件放到一个文件箱中，再搬着文件箱从A房间移动到B房间。
在这个例子中，房间A和房间B分别是数据传输的起点和终点。起点和终点之间的走廊是Channel，临时存放纸质文件的文件箱是Buffer。
面向缓冲的特点：
- 双向的：通道可以用于读或写，也可以同时用于读写
- 面向字节块：程序每次可以从缓冲区中获取一组字节数据
- 缓冲的：缓冲中的数据可以被多次访问
- 任意访问：允许在缓冲中的数据中前后移动
2.4 两种模型的对比
Java BIO下的执行流程：
Java NIO下的执行流程：
3. Java NIO API
3.1 Buffer
Buffer（缓冲区）是Java NIO中提供的用于存储数据的容器。Buffer底层依靠数组来存储数据，并提供了对数据的结构化访问以及维护读写位置等信息的功能。
Buffer只能用于存储基本类型的数据。在NIO中，针对八种基本类型提供了7个实现类。考虑到实际过程中，数据是以字节的形式来存储和传输，所以更多的使用的是ByteBuffer。
Buffer是一个抽象类：
其中定义了4个关于底层数组信息的核心属性：
- capacity：容量位，用于标记该缓冲区的容量，缓冲区创建好之后不可变
- position：操作位，用于指向要操作的位置，实际意义类似于数组中的下标，在缓冲区刚创建的时候指向0
- limit：限制位，用于限制操作位position所能达到的最大位置。在缓冲区刚创建的时候指向容量位
- mark：标记位，用于进行标记，在缓冲区刚创建的时候指向-1，默认不启用
Buffer初始时的状态：
示例代码：
输出结果：
Buffer写入部分数据后的状态：
示例代码：
输出结果：
Buffer反转后的状态：
示例代码：
输出结果：
import java.nio.ByteBuffer;
public class BufferDemo {
public static void main(String[] args) {
//创建Buffer
ByteBuffer buf = ByteBuffer.allocate(10);
printBufferState(buf);
// 写入数据到ByteBuffer
String message = "Hello NIO";
buf.put(message.getBytes());
System.out.println("Before flip():");
printBufferState(buf);
// 反转缓冲区
buf.flip();
// 打印切换到读模式后的状态
System.out.println("After flip():");
printBufferState(buf);
// 读取数据
byte[] data = new byte[buf.limit()];
buf.get(data);
// 打印读取到的数据
System.out.println("Read data: " + new String(data));
}
public static void printBufferState(ByteBuffer buf){
//输出3个变量的值
System.out.println("position="+buf.position()+",limit="+buf.limit()+",capacity="+buf.capacity());
}
}
3.2 Channel
Channel（通道）是Java NIO中提供的用于传输数据的工具，代表了源节点和目标节点之间的数据通道。Channel与Stream相似，但是略有不同：
- Channel是双向的
- Channel默认是阻塞的，可以设置为非阻塞
- Channel是面向缓冲区操作的
Java NIO中常用的Channel实现类如下：
其中：
- FileChannel：从文件读取数据和向文件读取数据
- DatagramChannel：可以通过UDP协议在网络上读写数据
- SocketChannel：可以通过TCP协议在网络上读写数据
- ServerSocketChannel：允许您侦听传入的 TCP 连接，就像 Web 服务器一样。 对于每个传入连接，都会创建一个 SocketChannel
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class FileChannelDemo {
public static void main(String[] args) throws Exception {
readDemo();
writeDemo();
}
public static void readDemo() throws Exception {
RandomAccessFile aFile = new RandomAccessFile("data/hello.txt", "rw");
FileChannel inChannel = aFile.getChannel();
ByteBuffer buf = ByteBuffer.allocate(10);
int bytesRead = inChannel.read(buf);
while (bytesRead != -1) {
System.out.println("\n====>Read " + bytesRead);
buf.flip();
while(buf.hasRemaining()){
System.out.print((char) buf.get()+" ");
}
buf.clear();
bytesRead = inChannel.read(buf);
}
aFile.close();
}
public static void writeDemo() throws Exception {
RandomAccessFile aFile = new RandomAccessFile("data/hello2.txt", "rw");
FileChannel channel = aFile.getChannel();
ByteBuffer buf = ByteBuffer.wrap("Hello Channel!".getBytes());
int len=channel.write(buf);
System.out.println("len="+len);
aFile.close();
}
}
3.3 Selector
Selector 是 Java NIO 提供的一个组件，它可以检查一个或多个Channel 实例，并确定哪些通道准备好用于读、写等操作。 通过这种方式，单个线程可以管理多个通道，从而管理多个网络连接。
Selector是基于事件驱动的，供提供了4类事件：connect、accept、read和write。
这四类事件定义在SelectionKey中：
- SelectionKey.OP_CONNECT
- SelectionKey.OP_ACCEPT
- SelectionKey.OP_READ
- SelectionKey.OP_WRITE
想要使用Selector来管理Channel，需要先向Selector注册该Channel实例，可以通过SelectableChannel.register()方法实现。
// 将channel设置为非阻塞模式
channel.configureBlocking(false);
// 将通道注册到选择器，并指定关注事件为读事件
SelectionKey key = channel.register(selector, SelectionKey.OP_READ);
需要注意，Channel 必须处于非阻塞模式才能与 Selector 一起使用。 也就是说，不能将 FileChannel 与 Selector 一起使用，因为 FileChannel 无法切换到非阻塞模式。SocketChannel是可以与Selector搭配使用的。
创建一个ServerSocketChannel监听8080端口，并使用Selector来处理客户端的连接和数据读取。同时，创建了多个客户端线程，模拟并发访问。每个客户端线程会连接到服务器，并发送数据，然后接收服务器的响应。
Server端程序代码：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;
public class Server {
public static void main(String[] args) throws IOException {
// 创建Selector
Selector selector = Selector.open();
// 创建ServerSocketChannel并绑定端口
ServerSocketChannel serverChannel = ServerSocketChannel.open();
serverChannel.bind(new InetSocketAddress(8080));
serverChannel.configureBlocking(false);
// 将ServerSocketChannel注册到Selector上，并指定感兴趣的事件为接收连接事件
serverChannel.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Server started.");
while (true) {
// Selector进行事件轮询
selector.select();
// 获取触发的事件集合
Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectedKeys.iterator();
while (iterator.hasNext()) {
SelectionKey key = iterator.next();
iterator.remove();
if (key.isAcceptable()) {
// 接收连接事件
handleAccept(key);
} else if (key.isReadable()) {
// 可读事件
handleRead(key);
}
}
}
}
private static void handleAccept(SelectionKey key) throws IOException {
ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
SocketChannel clientChannel = serverChannel.accept();
clientChannel.configureBlocking(false);
clientChannel.register(key.selector(), SelectionKey.OP_READ);
System.out.println("Accepted new connection from: " + clientChannel.getRemoteAddress());
}
private static void handleRead(SelectionKey key) throws IOException {
SocketChannel clientChannel = (SocketChannel) key.channel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int bytesRead = clientChannel.read(buffer);
if (bytesRead == -1) {
System.out.println("Connection closed by client: " + clientChannel.getRemoteAddress());
// 客户端关闭连接
clientChannel.close();
} else if (bytesRead > 0) {
// 处理接收到的数据
buffer.flip();
byte[] data = new byte[buffer.limit()];
buffer.get(data);
System.out.println("Received data from " + clientChannel.getRemoteAddress() + ": " + new String(data));
// 回写响应数据
String response = "Response from server";
ByteBuffer responseBuffer = ByteBuffer.wrap(response.getBytes());
clientChannel.write(responseBuffer);
}
}
}
Client端程序代码：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
public class Client {
public static void main(String[] args) {
for (int i = 0; i < 5; i++) {
Thread clientThread = new Thread(new ClientRunnable());
clientThread.start();
}
}
static class ClientRunnable implements Runnable {
@Override
public void run() {
try {
// 创建客户端SocketChannel并连接到服务器
SocketChannel clientChannel = SocketChannel.open();
clientChannel.configureBlocking(false);
clientChannel.connect(new InetSocketAddress("localhost", 8080));
// 等待连接完成
while (!clientChannel.finishConnect()) {
Thread.sleep(100);
}
// 发送数据到服务器
String message = "Hello from client";
ByteBuffer buffer = ByteBuffer.wrap(message.getBytes());
clientChannel.write(buffer);
// 接收服务器响应
ByteBuffer responseBuffer = ByteBuffer.allocate(1024);
while (clientChannel.read(responseBuffer) <= 0) {
// 等待服务器响应
Thread.sleep(100);
}
responseBuffer.flip();
byte[] responseData = new byte[responseBuffer.limit()];
responseBuffer.get(responseData);
System.out.println( clientChannel.getLocalAddress()+"=>Received response from server: " + new String(responseData));
// 关闭客户端连接
clientChannel.close();
} catch (IOException | InterruptedException e) {
e.printStackTrace();
}
}
}
}
4. 总结
1、阻塞（Blocking）和非阻塞（Nonblocking）描述的是线程在访问某个资源时，在该资源没有准备就绪期间的处理方式
- 阻塞：阻塞是指在进行I/O操作时，当前线程会被挂起，等待数据的就绪或操作的完成
- 非阻塞：非阻塞是指进行I/O操作时，当前线程不会被挂起，而是立即返回并继续执行其他任务
2、同步（synchronous）与异步（asynchronous）描述的是线程在发出请求后，是否等待结果
- 同步是指程序按照顺序执行，并等待某个操作完成后再继续执行下一个操作
- 在异步操作中，程序不会阻塞等待结果的返回，而是通过回调、轮询或事件通知等机制来获取结果或处理完成的事件
3、当涉及I/O操作时，可以根据是否阻塞和是否异步的角度将其分为以下四类
- 阻塞式I/O（Blocking I/O）
- 非阻塞式I/O（Non-Blocking I/O）
- I/O多路复用（I/O Multiplexing）
- 异步I/O（Asynchronous I/O）
4、在Java编程中提到的BIO、NIO和AIO，一般指的是Java语言为实现不同类型的I/O操作所提供的API
- Java IO：Java IO是JDK 1.0版本其自带的用于读取和写入数据的API，因其同步、阻塞的特征，被归类为同步阻塞式IO（Blocking IO），即Java BIO
- Java NIO（New IO）：是JDK 1.4开始提供的同步非阻塞式的IO操作API，因其同步、非阻塞的特征，开发者一般将Java NIO理解为Java Non-Blocking IO
- Java NIO 2.0：是JDK 1.7开始提供的异步非阻塞式的IO操作API，因其是在NIO的基础上进行了改进，称为NIO 2.0；因其异步、非阻塞的特征，开发者一般将Java NIO 2.0称为Java AIO
5、Java BIO和NIO采用了2种不同的模型
- BIO使用了面向流（Stream Oriented）的模型
- Java NIO使用了面向缓冲区（Buffer Oriented）的，基于通道（Channel Based）的模型
6、Java NIO编程中的核心API包括Buffer、Channel和Selector
- Buffer（缓冲区）是Java NIO中提供的用于存储数据的容器，底层依靠数组来存储数据，并提供了对数据的结构化访问以及维护读写位置等信息的功能
- Channel（通道）是Java NIO中提供的用于传输数据的工具，代表了源节点和目标节点之间的数据通道
- Selector 是 Java NIO 提供的一个组件，它可以检查一个或多个Channel 实例，并确定哪些通道准备好用于读、写等操作，通过这种方式，单个线程可以管理多个通道，从而管理多个网络连接