详细谈谈AIO、BIO、NIO 的区别

我会带着你远行 2024-03-22 23:28 60阅读 0赞

**目录**

一、什么是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的特点，可以同时处理多个任务，提高程序的效率。

![4573c0a501934393a6278fcf63107218.png][]

## 二、什么是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模型中的输入输出操作是阻塞的，也就是说当没有数据可读取或写入时，程序会一直阻塞在相应的读取或写入操作处，直到有数据或者操作完成才会继续执行。

![40e0349bc76243998cae74f77fa41816.png][]

## 三、什么是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`，实现了从源文件复制数据到目标文件操作。需要注意的是，该示例中只是简单地进行文件复制，并未处理异常情况和完善错误处理。在实际应用中，可能需要进一步优化和处理相关逻辑。

![de9ba829bfa24cac83577d2645737e1f.png][]

## 四、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功能进行更复杂的网络应用程序开发。

[4573c0a501934393a6278fcf63107218.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/16345e35b0154c029708d817e4403a04.png
[40e0349bc76243998cae74f77fa41816.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a6b1dcf3e9ac46e7bd3890e5cf0a86ab.png
[de9ba829bfa24cac83577d2645737e1f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9a4e88220c37407894ac4ca340de0e60.png