BIO、NIO、AIO和Netty网络编程模型比较和实践

发布时间：2023-09-11 19:20:36 (有修改)
本文热度：浏览 591 赞 0 评论 0
文章标签： Java 网络面试
全文共1字，阅读约需1分钟

1. 引言

网络通信是现代软件开发中必不可少的一个组成部分。为了实现高效的网络通信，开发人员需要掌握不同的网络编程模型。在Java中，常用的网络编程模型有BIO（Blocking IO）、NIO（Non-Blocking IO）和AIO（Asynchronous IO）。而Netty是一个基于NIO的高性能网络编程框架，提供了简单而强大的API，使得开发人员能够轻松地构建高性能的网络应用程序。本文讲介绍这几种io模型帮助大家更好的理解。

1.1 同步与异步，阻塞与非阻塞的区别

在了解不同的IO之前先了解：同步与异步，阻塞与非阻塞的区别

同步，一个任务的完成之前不能做其他操作，必须等待（等于在打电话）
异步，一个任务的完成之前，可以进行其他操作（等于在聊QQ）
阻塞，是相对于CPU来说的，挂起当前线程，不能做其他操作只能等待
非阻塞,，无须挂起当前线程，可以去执行其他操作

1.2 一个通俗例子读懂BIO、NIO、AIO

一个经典生活的例子：

小明去吃同仁四季的椰子鸡，就这样在那里排队，等了一小时，然后才开始吃火锅。(BIO)
小红也去同仁四季的椰子鸡，她一看要等挺久的，于是去逛会商场，每次逛一下，就跑回来看看，是不是轮到她了。于是最后她既购了物，又吃上椰子鸡了。（NIO）
小华一样，去吃椰子鸡，由于他是高级会员，所以店长说，你去商场随便逛会吧，等下有位置，我立马打电话给你。于是小华不用干巴巴坐着等，也不用每过一会儿就跑回来看有没有等到，最后也吃上了美味的椰子鸡（AIO）

2. BIO（Blocking IO）

2.1 原理和特点

BIO是最传统的网络编程模型，它基于阻塞I/O模式实现。在BIO模型中，当一个线程执行读/写操作时，如果没有数据可用或写入操作无法立即完成，线程将被阻塞。这导致BIO模型在高并发情况下性能较差。BIO模型的示意图如下：

2.2 使用方法

在Java中，使用BIO进行网络编程主要涉及以下几个核心类：ServerSocket、Socket、InputStream和OutputStream。下面是一个简单的BIO服务器示例：

public class BIOServer {
    public static void main(String[] args) throws IOException {
        // 创建ServerSocket并绑定端口
        ServerSocket serverSocket = new ServerSocket(8080);
        System.out.println("服务器已启动，监听8080端口...");

        while (true) {
            // 接受客户端连接请求
            Socket socket = serverSocket.accept();
            System.out.println("接受到客户端连接：" + socket.getRemoteSocketAddress());

            // 创建输入流和输出流
            InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream();

            // 读取客户端发送的数据
            byte[] buffer = new byte[1024];
            int length = inputStream.read(buffer);
            String request = new String(buffer, 0, length);
            System.out.println("接收到客户端数据：" + request);

            // 处理请求并返回响应
            String response = "Hello, " + request;
            outputStream.write(response.getBytes());
            outputStream.flush();

            // 关闭流和Socket连接
            inputStream.close();
            outputStream.close();
            socket.close();
        }
    }
}

3. NIO（Non-Blocking IO）

3.1 原理和特点

NIO是Java 1.4 引入的一组全新的I/O API，它基于事件驱动和非阻塞I/O模式实现。在NIO模型中，当一个线程执行读/写操作时，如果没有数据可用或写入操作无法立即完成，线程将继续执行其他任务，而不会被阻塞。这使得NIO模型能够处理更多的并发连接，并提供更好的性能。

NIO模型的示意图如下：

3.2 使用方法

在Java中，使用NIO进行网络编程涉及以下几个核心类：Selector、ServerSocketChannel、SocketChannel和ByteBuffer。下面是一个简单的NIO服务器示例：

public class NIOServer {
    public static void main(String[] args) throws IOException {
        // 创建ServerSocketChannel并绑定端口
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        serverSocketChannel.socket().bind(new InetSocketAddress(8080));
        serverSocketChannel.configureBlocking(false);
        System.out.println("服务器已启动，监听8080端口...");

        Selector selector = Selector.open();
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);

        while (true) {
            selector.select();

            Iterator<SelectionKey> iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                iterator.remove();

                if (key.isAcceptable()) {
                    ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
                    SocketChannel socketChannel = serverChannel.accept();
                    socketChannel.configureBlocking(false);
                    socketChannel.register(selector, SelectionKey.OP_READ | SelectionKey.OP_WRITE);
                    System.out.println("接受到客户端连接：" + socketChannel.getRemoteAddress());
                }

                if (key.isReadable()) {
                    SocketChannel socketChannel = (SocketChannel) key.channel();
                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    int length = socketChannel.read(buffer);
                    String request = new String(buffer.array(), 0, length);
                    System.out.println("接收到客户端数据：" + request);

                    String response = "Hello, " + request;
                    socketChannel.write(ByteBuffer.wrap(response.getBytes()));
                }
            }
        }
    }
}

4. AIO（Asynchronous IO）

4.1 原理和特点

AIO是Java 1.7 引入的一组新的异步IO API，它基于事件驱动和异步回调机制实现。在AIO模型中，当一个异步I/O操作被触发后，线程不会被阻塞，而是继续执行其他任务。当操作完成时，系统会回调预先注册的回调函数来处理操作结果。

4.2 使用方法

在Java中，使用AIO进行网络编程涉及以下几个核心类：AsynchronousServerSocketChannel、AsynchronousSocketChannel和CompletionHandler。下面是一个简单的AIO服务器示例：

public class AIOServer {
    public static void main(String[] args) throws IOException {
        // 创建AsynchronousServerSocketChannel并绑定端口
        AsynchronousServerSocketChannel serverSocketChannel = AsynchronousServerSocketChannel.open();
        serverSocketChannel.bind(new InetSocketAddress(8080));
        System.out.println("服务器已启动，监听8080端口...");

        serverSocketChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
            @Override
            public void completed(AsynchronousSocketChannel socketChannel, Object attachment) {
                serverSocketChannel.accept(null, this);

                try {
                    System.out.println("接受到客户端连接：" + socketChannel.getRemoteAddress().toString());

                    ByteBuffer buffer = ByteBuffer.allocate(1024);
                    socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
                        @Override
                        public void completed(Integer result, ByteBuffer attachment) {
                            attachment.flip();
                            String request = new String(attachment.array(), 0, attachment.limit());
                            System.out.println("接收到客户端数据：" + request);

                            String response = "Hello, " + request;
                            socketChannel.write(ByteBuffer.wrap(response.getBytes()), null, new CompletionHandler<Integer, Object>() {
                                @Override
                                public void completed(Integer result, Object attachment) {
                                    try {
                                        socketChannel.close();
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                    }
                                }

                                @Override
                                public void failed(Throwable exc, Object attachment) {
                                    try {
                                        socketChannel.close();
                                    } catch (IOException e) {
                                        e.printStackTrace();
                                    }
                                }
                            });
                        }

                        @Override
                        public void failed(Throwable exc, ByteBuffer attachment) {
                            try {
                                socketChannel.close();
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        }
                    });
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            @Override
            public void failed(Throwable exc, Object attachment) {
                serverSocketChannel.accept(null, this);
            }
        });

        try {
            Thread.sleep(Integer.MAX_VALUE);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

5. Netty

5.1 原理和特点

Netty是一个基于NIO的高性能网络编程框架，提供了简单而强大的API和丰富的功能组件。Netty的核心是事件驱动和异步模型，它使得开发人员能够轻松构建高性能、高可靠性的网络应用程序。

Netty的核心组件包括：Channel、EventLoop、ChannelHandler和ChannelPipeline。它们相互协作，完成网络通信过程中的各种事件和处理逻辑。

5.2 使用方法

使用Netty进行网络编程的第一步是创建一个ServerBootstrap实例，并配置相应的参数和事件处理器。下面是一个简单的Netty服务器示例：

public class NettyServer {
    public static void main(String[] args) {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap bootstrap = new ServerBootstrap();
            bootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel channel) throws Exception {
                            channel.pipeline().addLast(new SimpleChannelInboundHandler<String>() {
                                @Override
                                protected void channelRead0(ChannelHandlerContext ctx, String msg) throws Exception {
                                    System.out.println("接收到客户端数据：" + msg);

                                    String response = "Hello, " + msg;
                                    ctx.writeAndFlush(response);
                                }
                            });
                        }
                    });

            ChannelFuture future = bootstrap.bind(8080).sync();
            System.out.println("服务器已启动，监听8080端口...");

            future.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

6. 总结

本文详细介绍了BIO、NIO、AIO和Netty的原理、特点及使用方法，并提供了简单的示例代码。通过比较不同的网络编程模型，读者可以根据自己的需求选择合适的模型。Netty作为一个高性能的网络编程框架，特别适合构建复杂的网络应用程序。

通过学习和实践，你将能够更好地理解和应用这些网络编程模型，并为自己的项目选择适合的技术方案。

正文到此结束

所属分类：Java技术

本文链接： https://refblogs.com/article/531
版权声明： 本文由老牛原创发布，转载或复制请以超链接形式转载,并注明出处搬砖的码农。