Java AIO使用案例和说明

已于 2024-12-30 11:02:34 修改
阅读量565 收藏 10
点赞数 3
分类专栏： 网络协议 文章标签： AIO NIO java
于 2024-12-27 14:12:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wuxiaolongah/article/details/144767962
版权

Java AIO（Asynchronous I/O），也称为 NIO.2，是在 Java 7 中引入的一种新的 I/O 模型。它提供了真正的异步文件和套接字操作，允许应用程序在不阻塞当前线程的情况下发起 I/O 请求，并通过回调机制或 Future 来接收操作结果。AIO 的主要特点包括非阻塞、异步操作以及通过完成处理器（CompletionHandler）通知事件。

AIO 的优势

真正异步：所有 I/O 操作都是异步执行，不会阻塞当前线程。
回调机制：使用 CompletionHandler 接口，在 I/O 操作完成后得到通知。
简化并发处理：由于 I/O 操作不会阻塞线程，因此可以更有效地管理线程资源。
零拷贝支持：某些情况下可以减少数据复制次数，提高性能。

AIO 的局限性

尽管 AIO 提供了强大的功能，但在实际应用中也存在一些局限：

操作系统依赖：AIO 的实现依赖于底层操作系统的支持，不同平台上的性能和行为可能有所差异。
复杂度增加：编写基于 AIO 的代码可能会比传统的同步代码更加复杂，尤其是当涉及到多个异步操作的协调时。
生态不够成熟：与 NIO 相比，AIO 的生态系统还不够成熟，相关的库和工具较少。

AIO 示例代码

下面是一个简单的例子，展示了如何使用 Java AIO 进行异步读写操作。我们将创建一个服务器端程序，该程序能够接收来自客户端的消息并回显给客户端。

服务端代码（AsyncEchoServer.java）
package com.wuxiaolong.socket.nio;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousServerSocketChannel;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.nio.charset.StandardCharsets;
import java.util.concurrent.CountDownLatch;

public class AsyncEchoServer {

    private final int port;

    public AsyncEchoServer(int port) {
        this.port = port;
    }

    public void start() throws Exception {
        // 创建异步服务器套接字通道
        AsynchronousServerSocketChannel serverChannel = AsynchronousServerSocketChannel.open();
        serverChannel.bind(new InetSocketAddress(port));
        System.out.println("服务器已启动，监听端口 " + port);

        // 异步接受连接请求
        serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
            @Override
            public void completed(AsynchronousSocketChannel clientChannel, Void attachment) {

                // 当有新的客户端连接时触发
                try {
                    System.out.println("新客户端连接: " + clientChannel.getRemoteAddress());
                } catch (IOException e) {
                    e.printStackTrace();
                }

                // 继续接受其他连接
                serverChannel.accept(null, this);

                // 异步读取客户端消息
                ByteBuffer buffer = ByteBuffer.allocate(256);
                clientChannel.read(buffer, buffer, new EchoCompletionHandler(clientChannel));
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                // 处理连接失败的情况
                exc.printStackTrace();
                try {
                    serverChannel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        });

        // 阻塞主线程以保持服务器运行
        CountDownLatch latch = new CountDownLatch(1);
        latch.await();
    }


    // 自定义的完成处理器，用于处理读取和写入操作
    class EchoCompletionHandler implements CompletionHandler<Integer, ByteBuffer> {

        private final AsynchronousSocketChannel channel;

        public EchoCompletionHandler(AsynchronousSocketChannel channel) {
            this.channel = channel;
        }

        @Override
        public void completed(Integer result, ByteBuffer attachment) {
            if (result == -1) {
                // 如果读取到 -1 表示客户端关闭了连接
                try {
                    channel.close();
                    System.out.println("客户端断开连接");
                } catch (IOException e) {
                    e.printStackTrace();
                }
                return;
            }

            // 翻转缓冲区准备读取数据
            attachment.flip();
            byte[] messageBytes = new byte[attachment.remaining()];
            attachment.get(messageBytes);
            String message = new String(messageBytes, StandardCharsets.UTF_8);
            System.out.println("收到消息: " + message);

            // 准备回显数据
            attachment.rewind(); // 重置位置指针
            channel.write(attachment, attachment, this); // 回显消息给客户端
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            // 处理读写失败的情况
            exc.printStackTrace();
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }


    public static void main(String[] args) throws Exception {
        int port = 8080;
        new AsyncEchoServer(port).start();
    }
}
客户端代码（AsyncEchoClient.java）
import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.AsynchronousSocketChannel;
import java.nio.channels.CompletionHandler;
import java.util.concurrent.CountDownLatch;

public class AsyncEchoClient {

    private final String host;
    private final int port;

    public AsyncEchoClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void start() throws Exception {
        // 创建异步套接字通道
        AsynchronousSocketChannel channel = AsynchronousSocketChannel.open();

        // 异步连接到服务器
        final CountDownLatch connectLatch = new CountDownLatch(1);
        channel.connect(new InetSocketAddress(host, port), null, new CompletionHandler<Void, Void>() {
            @Override
            public void completed(Void result, Void attachment) {
                System.out.println("已连接到服务器");

                // 发送一条消息给服务器
                ByteBuffer buffer = ByteBuffer.wrap("Hello, AIO!".getBytes(StandardCharsets.UTF_8));
                channel.write(buffer, buffer, new WriteCompletionHandler(channel));

                // 关闭连接后退出
                connectLatch.countDown();
            }

            @Override
            public void failed(Throwable exc, Void attachment) {
                // 处理连接失败的情况
                exc.printStackTrace();
                connectLatch.countDown();
            }
        });

        // 等待连接完成
        connectLatch.await();
    }

    // 写完成处理器
    class WriteCompletionHandler implements CompletionHandler<Integer, ByteBuffer> {
        private final AsynchronousSocketChannel channel;

        public WriteCompletionHandler(AsynchronousSocketChannel channel) {
            this.channel = channel;
        }

        @Override
        public void completed(Integer result, ByteBuffer attachment) {
            if (result > 0) {
                // 写入成功后准备读取响应
                attachment.flip();
                channel.read(attachment, attachment, new ReadCompletionHandler(channel));
            }
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            // 处理写入失败的情况
            exc.printStackTrace();
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    // 读完成处理器
    class ReadCompletionHandler implements CompletionHandler<Integer, ByteBuffer> {
        private final AsynchronousSocketChannel channel;

        public ReadCompletionHandler(AsynchronousSocketChannel channel) {
            this.channel = channel;
        }

        @Override
        public void completed(Integer result, ByteBuffer attachment) {
            if (result > 0) {
                // 读取成功后打印响应
                attachment.flip();
                byte[] messageBytes = new byte[attachment.remaining()];
                attachment.get(messageBytes);
                String message = new String(messageBytes, StandardCharsets.UTF_8);
                System.out.println("服务器回显: " + message);

                // 关闭连接
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

        @Override
        public void failed(Throwable exc, ByteBuffer attachment) {
            // 处理读取失败的情况
            exc.printStackTrace();
            try {
                channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws Exception {
        String host = "localhost";
        int port = 8080;
        new AsyncEchoClient(host, port).start();
    }
}
关键点解释
  • AsynchronousServerSocketChannel 和 AsynchronousSocketChannel：分别代表服务器端和客户端的异步套接字通道。它们允许我们以非阻塞的方式进行网络通信。
  • CompletionHandler：这是一个接口，用来定义当某个异步操作（如连接、读取、写入）完成时应该执行的逻辑。每个操作都可以指定自己的 CompletionHandler 实例。
  • CountDownLatch：用于阻塞主线程，直到所有的异步操作完成。这在测试环境中非常有用，可以确保程序不会提前结束。
  • ByteBuffer：作为数据传输的载体，所有读写操作都必须通过 ByteBuffer 进行。

总结

上述代码展示了如何使用 Java AIO 构建一个简单的回显服务器和客户端。AIO 提供了一种真正异步的方式来处理 I/O 操作，但它也有一些局限性。对于大多数应用场景来说，Netty 或者传统的 NIO 可能是更好的选择，因为它们更加成熟且具有广泛的社区支持。然而，了解 AIO 对于深入理解 Java 的 I/O 模型是非常有价值的。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值