Java NIO - 版本历史

Riguz：Riguz移动页面Blog:Linux I/O模型与Java NIO至Java NIO，不留重定向

2023-12-19T05:58:03Z

Riguz移动页面Blog:Linux I/O模型与Java NIO至Java NIO，不留重定向

←上一版本		2023年12月19日 (二) 05:58的版本
（没有差异）

Riguz：/* Asynchronous I/O */

2021-04-30T07:01:15Z

Asynchronous I/O

←上一版本		2021年4月30日 (五) 07:01的版本
第222行：		第222行：
	* [https://www.baeldung.com/java-nio-selector Introduction to the Java NIO Selector]		* [https://www.baeldung.com/java-nio-selector Introduction to the Java NIO Selector]
	* [https://stackoverflow.com/questions/27541283/io-performance-selector-nio-vs-asynchronouschannelnio-2 IO performance: Selector (NIO) vs AsynchronousChannel(NIO.2)]		* [https://stackoverflow.com/questions/27541283/io-performance-selector-nio-vs-asynchronouschannelnio-2 IO performance: Selector (NIO) vs AsynchronousChannel(NIO.2)]

			[[Category:I/O]]

Riguz：/* Asynchronous I/O */

2021-04-30T06:54:01Z

Asynchronous I/O

←上一版本		2021年4月30日 (五) 06:54的版本
第212行：		第212行：
	但性能上可能并没有太大的提升（Linux平台），以致于Netty中移除了对NIO.2的支持：		但性能上可能并没有太大的提升（Linux平台），以致于Netty中移除了对NIO.2的支持：

	> I don't think NIO.2 will have better performance than NIO, because NIO.2 still make use of select/poll system calls and thread pools to simulate asynchronous IO. One example is that Netty removed NIO.2 support in 4.0.0, because the author think that NIO.2 doesn't bring better performance than NIO in Linux platform.		<q> I don't think NIO.2 will have better performance than NIO, because NIO.2 still make use of select/poll system calls and thread pools to simulate asynchronous IO. One example is that Netty removed NIO.2 support in 4.0.0, because the author think that NIO.2 doesn't bring better performance than NIO in Linux platform.
			</q>

	See also:		See also:

Riguz：/* Asynchronous I/O */

2021-04-30T03:12:38Z

Asynchronous I/O

←上一版本		2021年4月30日 (五) 03:12的版本
第206行：		第206行：
	Java支持AIO，具体有这些类：		Java支持AIO，具体有这些类：

	* `AsynchronousFileChannel`: 用于文件异步读写；		* <span class="article-label">AsynchronousFileChannel</span>: 用于文件异步读写；
	* `AsynchronousSocketChannel`: 客户端异步socket；		* <span class="article-label">AsynchronousSocketChannel</span>: 客户端异步socket；
	* `AsynchronousServerSocketChannel`: 服务器异步socket。		* <span class="article-label">AsynchronousServerSocketChannel</span>: 服务器异步socket。

	但性能上可能并没有太大的提升（Linux平台），以致于Netty中移除了对NIO.2的支持：		但性能上可能并没有太大的提升（Linux平台），以致于Netty中移除了对NIO.2的支持：

Riguz：/* non-blocking I/O */

2021-04-30T03:12:11Z

non-blocking I/O

←上一版本		2021年4月30日 (五) 03:12的版本
第140行：		第140行：
	* Selectors, selection keys: 用来实现multiplexed, non-blocking I/O机制		* Selectors, selection keys: 用来实现multiplexed, non-blocking I/O机制

	~~其中，`Buffer`中可以存储固定大小的容器，而其中的`~~ByteBuffer`类比较特殊：		其中，Buffer中可以存储固定大小的容器，而其中的<span class="article-label">ByteBuffer</span>类比较特殊：

	* 可以作为I/O操作的目标		* 可以作为I/O操作的目标
	* 可以分配为direct buffer，JVM会尝试进行原生的I/O操作以提高性能		* 可以分配为direct buffer，JVM会尝试进行原生的I/O操作以提高性能
	* 可以直接map文件的一部分到buffer中(`MappedByteBuffer`)，支持一些额外的文件操作		* 可以直接map文件的一部分到buffer中(<span class="article-label">MappedByteBuffer</span>)，支持一些额外的文件操作
	* 可以自定义字节序		* 可以自定义字节序

Riguz：/* Signal driven I/O */

2021-04-30T03:11:07Z

Signal driven I/O

←上一版本		2021年4月30日 (五) 03:11的版本
第73行：		第73行：

	=== Signal driven I/O===		=== Signal driven I/O===
	这种模式下首先将socket设置为singal-driven，然后通过`sigaction`注册一个回调。这个过程不是block的，一旦数据ready之后，一个`SIGIO`的信号会发送到process中，然后拷贝数据阶段依然是blocking的。		这种模式下首先将socket设置为singal-driven，然后通过<span class="article-label">sigaction</span>注册一个回调。这个过程不是block的，一旦数据ready之后，一个<span class="article-label">SIGIO</span>的信号会发送到process中，然后拷贝数据阶段依然是blocking的。

	<syntaxhighlight lang="c++">		<syntaxhighlight lang="c++">

Riguz：/* I/O multiplexing */

2021-04-30T03:10:43Z

I/O multiplexing

←上一版本		2021年4月30日 (五) 03:10的版本
第39行：		第39行：
	=== I/O multiplexing===		=== I/O multiplexing===

	I/O multiplexing(多路复用)是通过单个进程管理多个网络连接的一种方式，通常有`select`，`pool`和`epoll`等几种方式。在这种模式下，socket会被设置为non-blocking，通过不断轮询所有的socket，直到某个socket有数据则返回。		I/O multiplexing(多路复用)是通过单个进程管理多个网络连接的一种方式，通常有<span class="article-label">select</span>，<span class="article-label">pool</span>和<span class="article-label">epoll</span>等几种方式。在这种模式下，socket会被设置为non-blocking，通过不断轮询所有的socket，直到某个socket有数据则返回。

	<syntaxhighlight lang="c++">		<syntaxhighlight lang="c++">
第70行：		第70行：
	</syntaxhighlight>		</syntaxhighlight>

	除了使用`select`之外，还可以使用`pool`和`epoll`，但是本质上两个阶段都会block。看起来除了可以处理多个socket连接之外没啥好处，但是如果考虑到使用多线程的话，那么`recvfrom`可以在线程中处理，理论上可以提高吞吐。		除了使用<span class="article-label">select</span>之外，还可以使用<span class="article-label">pool</span>和<span class="article-label">epoll</span>，但是本质上两个阶段都会block。看起来除了可以处理多个socket连接之外没啥好处，但是如果考虑到使用多线程的话，那么<span class="article-label">recvfrom</span>可以在线程中处理，理论上可以提高吞吐。

	=== Signal driven I/O===		=== Signal driven I/O===

Riguz：/* Non-blocking I/O */

2021-04-30T03:09:53Z

Non-blocking I/O

←上一版本		2021年4月30日 (五) 03:09的版本
第29行：		第29行：
	=== Non-blocking I/O===		=== Non-blocking I/O===

	将socket设置为non-blocking之后，如果数据没有就绪的时候不会阻塞住请求进程而是立即返回一个错误(`EWOULDBLOCK`)，这样请求进程可以不断尝试去获取是否有数据就绪（这个过程称之为~~*~~polling~~*~~)。然而，在数据的拷贝阶段，这个过程还是blocking的。		将socket设置为non-blocking之后，如果数据没有就绪的时候不会阻塞住请求进程而是立即返回一个错误(<span class="article-label">EWOULDBLOCK</span>)，这样请求进程可以不断尝试去获取是否有数据就绪（这个过程称之为<span class="article-label">polling</span>)。然而，在数据的拷贝阶段，这个过程还是blocking的。

	<syntaxhighlight lang="c++">		<syntaxhighlight lang="c++">

Riguz：/* 同步于异步、阻塞与非阻塞 */

2021-04-30T03:08:57Z

同步于异步、阻塞与非阻塞

←上一版本		2021年4月30日 (五) 03:08的版本
第94行：		第94行：

	根据这个定义，除了AIO之外，其他四种都是synchronous的，因为数据复制阶段（recvfrom)是阻塞的。		根据这个定义，除了AIO之外，其他四种都是synchronous的，因为数据复制阶段（recvfrom)是阻塞的。

	~~[[File:http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/files/06fig06.gif\|600px\|I/O Models]]~~

	= Java中的I/O=		= Java中的I/O=

imported>Riguz：I/O 即Input与Output，包含了文件的读写或者是网络的I/O。在Linux/Unix中有五种I/O模型： * blocking I/O * nonblocking I/O * I/O multiplexing (select and poll) * signal driven I/O (SIGIO) * asynchronous I/O (the POSIX aio_functions) Java 从Java SE 1.4开始引入NIO，在Java 7推出了NIO 2。那么，不同的IO模型之间具体有什么差异，又该如何使用呢？

2020-08-26T00:00:00Z

新页面

I/O 即Input与Output，包含了文件的读写或者是网络的I/O。在Linux/Unix中有五种I/O模型：

* blocking I/O
* nonblocking I/O
* I/O multiplexing (select and poll)
* signal driven I/O (SIGIO)
* asynchronous I/O (the POSIX aio_functions)

Java 从Java SE 1.4开始引入NIO，在Java 7推出了NIO 2。那么，不同的IO模型之间具体有什么差异，又该如何使用呢？

= I/O 模型=

在I/O操作中，通常是分为两个阶段的：

* 首先是等待数据就绪。
* 然后将数据从kernel复制到process

例如在socket中，第一个阶段就是等待从网络发送数据过来，然后存入内核的缓冲区。然后第二个阶段，将接收到的数据从内核缓冲区拷贝到用户程序中。

== 五种I/O模型==
=== Blocking I/O===

Blocking I/O即阻塞式IO，在Linux中默认所有的socket都是blocking的。在这种模式下，两个阶段都是阻塞的。这个过程类似这样：

<syntaxhighlight lang="c++">
data = recvfrom(socket)
</syntaxhighlight>

=== Non-blocking I/O===

将socket设置为non-blocking之后，如果数据没有就绪的时候不会阻塞住请求进程而是立即返回一个错误(`EWOULDBLOCK`)，这样请求进程可以不断尝试去获取是否有数据就绪（这个过程称之为***polling***)。然而，在数据的拷贝阶段，这个过程还是blocking的。

<syntaxhighlight lang="c++">
do {
data = recvfrom(socket)
} while(data == EWOULDBLOCK)
</syntaxhighlight>

=== I/O multiplexing===

I/O multiplexing(多路复用)是通过单个进程管理多个网络连接的一种方式，通常有`select`，`pool`和`epoll`等几种方式。在这种模式下，socket会被设置为non-blocking，通过不断轮询所有的socket，直到某个socket有数据则返回。

<syntaxhighlight lang="c++">
while(true) {
socket = select(sockets) // 这里如果没有一个socket是就绪的就会一直阻塞
data = recvfrom(socket) // 同样从内核拷贝数据到process的时候也是block的
}
</syntaxhighlight>

一个更具体的例子：

<syntaxhighlight lang="c++">
while(1){
FD_ZERO(&rset);
for (i = 0; i< 5; i++ ) {
FD_SET(fds[i],&rset);
}

puts("round again");
select(max+1, &rset, NULL, NULL, NULL);

for(i=0;i<5;i++) {
if (FD_ISSET(fds[i], &rset)){
memset(buffer,0,MAXBUF);
read(fds[i], buffer, MAXBUF);
puts(buffer);
}
}
}
</syntaxhighlight>

除了使用`select`之外，还可以使用`pool`和`epoll`，但是本质上两个阶段都会block。看起来除了可以处理多个socket连接之外没啥好处，但是如果考虑到使用多线程的话，那么`recvfrom`可以在线程中处理，理论上可以提高吞吐。

=== Signal driven I/O===
这种模式下首先将socket设置为singal-driven，然后通过`sigaction`注册一个回调。这个过程不是block的，一旦数据ready之后，一个`SIGIO`的信号会发送到process中，然后拷贝数据阶段依然是blocking的。

<syntaxhighlight lang="c++">
handler = () -> {
recvfrom(socket)
}
sigaction(socket, handler)
</syntaxhighlight>

=== Asynchronous I/O===

在AIO模式下，两个阶段都是nonblocking的，跟signal-driven I/O模式的区别在于，前者是当数据ready之后通知应用去读取；而AIO是内核直接将数据拷贝到process完成之后通知process。

== 同步于异步、阻塞与非阻塞==

同步异步、阻塞和非阻塞比较confusing, POSIX中是这样定义的：

* 同步I/O是指请求的进程被阻塞一直到操作结束
* 异步I/O不导致请求进程阻塞

根据这个定义，除了AIO之外，其他四种都是synchronous的，因为数据复制阶段（recvfrom)是阻塞的。

[[File:http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/files/06fig06.gif|600px|I/O Models]]

= Java中的I/O=
== blocking I/O==
在Java中构建一个简单的Socket服务器，为每一个连接新建一个线程处理：

<syntaxhighlight lang="java">
public class EchoServer {
public static void main(String[] args) throws IOException {
ServerSocket server = new ServerSocket();
server.bind(new InetSocketAddress(9000));

while (true) {
Socket socket = server.accept();
new Thread(clientHandler(socket)).start();
}
}

private static Runnable clientHandler(Socket socket) {
return () -> {
try {
BufferedReader reader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
PrintWriter writer = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));

String line = "";
while (!"/quit".equals(line)) {
line = reader.readLine();
writer.write(line + "\n");
writer.flush();
}
} catch (IOException ex) {
ex.printStackTrace();
}
};
}
}
</syntaxhighlight>

== non-blocking I/O==

Java NIO中主要有以下的一些类：

* [https://docs.oracle.com/javase/8/docs/api/java/nio/package-summary.html#buffers Buffers]: 数据缓冲容器
* [https://docs.oracle.com/javase/8/docs/api/java/nio/charset/package-summary.html Charsets]: 字符集编码和解码
* [https://docs.oracle.com/javase/8/docs/api/java/nio/channels/package-summary.html Channels]: 可以进行I/O操作的连接
* Selectors, selection keys: 用来实现multiplexed, non-blocking I/O机制

其中，`Buffer`中可以存储固定大小的容器，而其中的`ByteBuffer`类比较特殊：

* 可以作为I/O操作的目标
* 可以分配为direct buffer，JVM会尝试进行原生的I/O操作以提高性能
* 可以直接map文件的一部分到buffer中(`MappedByteBuffer`)，支持一些额外的文件操作
* 可以自定义字节序

使用Nio实现一个EchoServer:

<syntaxhighlight lang="java">
public class NioEchoServer {
public static void main(String[] args) {
try (Selector selector = Selector.open();
ServerSocketChannel serverSocket = ServerSocketChannel.open()) {
serverSocket.bind(new InetSocketAddress(9999));
serverSocket.configureBlocking(false);
serverSocket.register(selector, SelectionKey.OP_ACCEPT);
ByteBuffer buffer = ByteBuffer.allocate(4);

while (true) {
selector.select();
final Set<SelectionKey> selectedKeys = selector.selectedKeys();
Iterator<SelectionKey> iterator = selectedKeys.iterator();
while (iterator.hasNext()) {
final SelectionKey key = iterator.next();
if (key.isAcceptable()) {
accept(selector, serverSocket);
} else if (key.isReadable()) {
readAndAnswer(buffer, key);
} else {
throw new RuntimeException("Unsupported operation");
}
iterator.remove();
}
}

} catch (IOException e) {
e.printStackTrace();
}
}

private static void accept(final Selector selector,
final ServerSocketChannel serverSocket)
throws IOException {
SocketChannel client = serverSocket.accept();
client.configureBlocking(false);
client.register(selector, SelectionKey.OP_READ);
}

private static void readAndAnswer(final ByteBuffer buffer,
final SelectionKey key)
throws IOException {
final SocketChannel client = (SocketChannel) key.channel();
client.read(buffer);
buffer.flip();
String s = StandardCharsets.UTF_8.decode(buffer).toString();
System.out.println("-> " + s);
buffer.clear();
}
}
</syntaxhighlight>

== Asynchronous I/O==

Java支持AIO，具体有这些类：

* `AsynchronousFileChannel`: 用于文件异步读写；
* `AsynchronousSocketChannel`: 客户端异步socket；
* `AsynchronousServerSocketChannel`: 服务器异步socket。

但性能上可能并没有太大的提升（Linux平台），以致于Netty中移除了对NIO.2的支持：

> I don't think NIO.2 will have better performance than NIO, because NIO.2 still make use of select/poll system calls and thread pools to simulate asynchronous IO. One example is that Netty removed NIO.2 support in 4.0.0, because the author think that NIO.2 doesn't bring better performance than NIO in Linux platform.

See also:

* [http://www.masterraghu.com/subjects/np/introduction/unix_network_programming_v1.3/ch06lev1sec2.html 6.2 I/O Models]
* [https://devarea.com/linux-io-multiplexing-select-vs-poll-vs-epoll/#.X0W520lS-L8 Linux – IO Multiplexing – Select vs Poll vs Epoll]
* [https://medium.com/@clu1022/%E6%B7%BA%E8%AB%87i-o-model-32da09c619e6 淺談I/O Model]
* [https://www.baeldung.com/java-nio-selector Introduction to the Java NIO Selector]
* [https://stackoverflow.com/questions/27541283/io-performance-selector-nio-vs-asynchronouschannelnio-2 IO performance: Selector (NIO) vs AsynchronousChannel(NIO.2)]

Java NIO - 版本历史

Riguz：​Riguz移动页面Blog:Linux I/O模型与Java NIO至Java NIO，不留重定向

Riguz：​/* Asynchronous I/O */

Riguz：​/* Asynchronous I/O */

Riguz：​/* Asynchronous I/O */

Riguz：​/* non-blocking I/O */

Riguz：​/* Signal driven I/O */

Riguz：​/* I/O multiplexing */

Riguz：​/* Non-blocking I/O */

Riguz：​/* 同步于异步、阻塞与非阻塞 */

Riguz：Riguz移动页面Blog:Linux I/O模型与Java NIO至Java NIO，不留重定向

Riguz：/* Asynchronous I/O */

Riguz：/* Asynchronous I/O */

Riguz：/* Asynchronous I/O */

Riguz：/* non-blocking I/O */

Riguz：/* Signal driven I/O */

Riguz：/* I/O multiplexing */

Riguz：/* Non-blocking I/O */

Riguz：/* 同步于异步、阻塞与非阻塞 */