目录
一、什么是AIO
二、什么是BIO
三、什么是NIO
四、NIO 在 Netty 中的使用
一、什么是AIO
AIO（Asynchronous I/O，异步输入输出）是一种处理输入输出的编程模型，它允许同时处理多个输入输出操作，而不需要等待每个操作完成。在Python中，可以使用asyncio库来实现AIO编程。
下面是一个使用asyncio库简单示例代码：
import asyncio
async def hello():
print("Hello")
await asyncio.sleep(1)
print("World")
async def main():
await asyncio.gather(hello(), hello())
asyncio.run(main())在这个示例中，hello函数是一个异步函数，它打印""，然后等待1秒钟，最后再打印"World"。main函数是另一个异步函数，它使用asyncio.gather方法同时运行两个hello任务。
通过asyncio.run(main())来运行main函数，它会创建一个事件循环并执行异任务。
运行上述代码，你会看到输出结果是交替打印的"Hello"和"World"，而不是等待一个任务完成后再执行另一个任务。这就是AIO的特点，可以同时处理多个任务，提高程序的效率。
二、什么是BIO
BIO（BlockI/O，阻塞输入输出）是一种传统的输入输出模型，它在执行输入输出操作时会阻塞程序的执行，直到操作完成才会进行下一步。在Java中，可以使用java.net包中的Socket和ServerSocket类来实现BIO编程。下面是一个简单的Java示例代码：
Server端代码：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
public static void main(String[] args) {
try {
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("Server started.");
while (true) {
Socket socket = serverSocket.accept();
System.out.println("Client connected.");
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();
byte[] buffer = new byte[1024];
int length;
while ((length = inputStream.read(buffer)) != -1) {
String message = new String(buffer, 0, length);
System.out.println("Received message: " + message);
outputStream.write(message.getBytes());
outputStream.flush();
}
socket.close();
System.out.println("Client disconnected.");
}
} catch (IOException e) {
e.printStackTrace();
}
}
}Client端代码：
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class Client {
public static void main(String[] args) {
try {
Socket socket = new Socket("localhost", 8888);
System.out.println("Connected to server.");
InputStream inputStream = socket.getInputStream();
OutputStream outputStream = socket.getOutputStream();
String message = "Hello, server!";
outputStream.write(message.getBytes());
outputStream.flush();
byte[] buffer = new byte[1024];
int length = inputStream.read(buffer);
String response = new String(buffer, 0, length);
System.out.println("Received response: " + response);
socket.close();
System.out.println("Disconnected from server.");
} catch (IOException e) {
e.printStackTrace();
}
}
}在这个示例中，Server端通过ServerSocket监听8888端口，当有Client连接时，会创建一个新的Socket来与Client进行通信。Server端使用InputStream来接收Client发送的消息，然后通过OutputStream发送响应消息给Client。Client端通过Socket连接到Server，并使用InputStream发送消息给Server，然后通过OutputStream接收Server的响应消息。
需要注意的是，BIO模型中的输入输出操作是阻塞的，也就是说当没有数据可读取或写入时，程序会一直阻塞在相应的读取或写入操作处，直到有数据或者操作完成才会继续执行。
三、什么是NIO
NIO（New IO）是Java中用于处理非阻塞I/O操作的API，它提供了一种更高效、更灵活的方式来进行网络编程。
下面是一个简单的Java NIO示例代码，展示了如何使用NIO进行文件复制操作：
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
public class NIOFileCopyExample {
public static void main(String[] args) {
String sourceFilePath = "path/to/source/file";
String destinationFilePath = "path/to/destination/file";
try {
// 创建输入流和流
FileInputStream fis = new FileInputStream(sourceFilePath);
FileOutputStream fos = new FileOutputStream(destinationFilePath);
// 创建输入流和输出流的通道
FileChannel inputChannel = fis.getChannel();
FileChannel outputChannel = fos.getChannel();
// 创建缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
// 从输入通道取数据到缓冲区
while (inputChannel.read(buffer) != -1) {
buffer.flip(); // 切换为读模式
// 从缓冲区写入数据到输出通道
outputChannel.write(buffer);
buffer.clear(); // 清空缓冲区
}
// 关闭通道和流
inputChannel.close();
outputChannel.close();
fis.close();
fos.close();
System.out.println("文件复制完成！");
} catch (Exception e) {
e.printStackTrace();
}
}
}以上代码通过使用NIO的FileChannel和ByteBuffer，实现了从源文件复制数据到目标文件操作。需要注意的是，该示例中只是简单地进行文件复制，并未处理异常情况和完善错误处理。在实际应用中，可能需要进一步优化和处理相关逻辑。
四、NIO 在 Netty 中的使用
在Netty中，NIO被广泛用于构建高性能的网络应用程序。Netty封装了Java NIO API，并提供了一套更简洁、易用的抽象层，使得开发者能够更方便地使用NIO进行网络编程。
下面是一个简单的Netty使用NIO的示例代码，展示了如何创建一个简单的Echo服务器：
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
public class EchoServer {
private int port;
public EchoServer(int port) {
this.port = port;
}
public void start() throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG, 128)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
public void initChannel(SocketChannel ch) throws Exception {
ch.pipeline().addLast(new StringEncoder(), new StringDecoder(), new EchoServerHandler());
}
});
// 绑定端口，开始接收进来的连接
b.bind(port).sync().channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
}
}
public static void main(String[] args) throws Exception {
int port = 8888;
new EchoServer(port).start();
}
}
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
public class EchoServerHandler extends ChannelInboundHandlerAdapter {
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
String message = (String) msg;
System.out.println("Received message: " + message);
ctx.write(message);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
ctx.flush();
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
cause.printStackTrace();
ctx.close();
}
}以上代码创建了一个简单的Echo服务器，当客户端连接到服务器并发送消息时，服务器将原样将消息返回给客户端。在该示例中，NioEventLoopGroup用于处理I/O事件的多线程事件循环组，NioServerSocketChannel用于创建服务器端的通道，ChannelOption.SO_BACKLOG设置了服务器的最大连接数，LoggingHandler用于记录日志。EchoServerHandler类继承自ChannelInboundHandlerAdapter，用于处理接收到的消息。
这只是一个简单的示例，你可以根据实际需求，使用Netty的NIO功能进行更复杂的网络应用程序开发。
