【AIO】Socket 编程：基于AIO的Server、Client 示例

心已赠人 2022-12-30 03:37 197阅读 0赞

Java AIO，全称 Asynchronous IO，也可称为 NIO2，在 JDK7 中引入，表示异步非阻塞的IO。AIO 实现了真正意义上的异步 I/O，它是直接将 I/O 操作交给操作系统进行异步处理，待完成后OS再通知服务端程序去执行具体逻辑。

NIO 是基于IO多路复用模型，底层采用 Reactor 设计模式，事件循环将文件句柄的状态事件通知给用户线程，由用户线程自行读取数据、处理数据。而 AIO 是基于异步IO模型，底层采用 Proactor 设计模式，当用户线程收到通知时，数据已经被内核读取完毕，并放在了用户线程指定的缓冲区内，内核在IO完成后通知用户线程直接使用即可。

所以，我们可以理解成 AIO 是对 JDK4 中提出的同步非阻塞 I/O(NIO) 的进一步增强。它在 NIO 的基础上引入了新的异步通道的概念，并提供了异步文件通道和异步套接字通道的实现。

*  AsynchronousFileChannel: 文件异步读写
 *  AsynchronousSocketChannel: 客户端异步 Socket
 *  AsynchronousServerSocketChannel: 服务端异步 Socket

> 另外，AIO 还提供了用户处理器 CompletionHandler 接口，通过这个接口实现应用程序向操作系统发起IO 请求。

### Server ###

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;
    
    public class Server {
        
    
        public static void main(String[] args) throws Exception {
        
        	// 创建 AIO 服务端
        	// 工作线程，用来侦听回调的，事件响应的时候需要回调
            final AsynchronousServerSocketChannel serverChannel =
                    AsynchronousServerSocketChannel.open().bind(new InetSocketAddress(8000));
            System.out.println("Server Started...");
    		
    		// 准备接受数据
    		// CompletionHandler 是用户处理器，由操作系统来触发
    		// CompletionHandler  需要实现两个方法：completed()--成功，failed()--失败，
            serverChannel.accept(null, new CompletionHandler<AsynchronousSocketChannel, Object>() {
        
            
                @Override
    			// 成功时触发回调
                public void completed(final AsynchronousSocketChannel socketChannel, Object attachment) {
        
                	// 在此接收客户端连接，如果不写这行代码后面的客户端连接连不上服务端
                    serverChannel.accept(attachment, this);
                    try {
        
                        System.out.println("有新连接：" + socketChannel.getRemoteAddress());
                        final ByteBuffer buffer = ByteBuffer.allocate(1024);
                        // 读取 Client 发送的数据
                        // read() 方法入参是缓冲区 buffer，和 一个用户处理器 CompletionHandler
                        socketChannel.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
        
                            @Override
                            public void completed(Integer result, ByteBuffer attachment) {
        
                                buffer.flip();
                                try {
        
                                    System.out.println(socketChannel.getRemoteAddress() + "：" + new String(buffer.array(), 0, result));
                                } catch (IOException e) {
        
                                    e.printStackTrace();
                                }
                                // 向 Client 发送数据
                                socketChannel.write(ByteBuffer.wrap("HelloClient".getBytes()));
                            }
    
                            @Override
                            public void failed(Throwable exc, ByteBuffer attachment) {
        
                                exc.printStackTrace();
                            }
                        });
                    } catch (Exception e) {
        
                        e.printStackTrace();
                    }
                }
    
                @Override
                // 失败时触发的回调
                public void failed(Throwable exc, Object attachment) {
        
                    exc.printStackTrace();
                }
            });
            Thread.sleep(Integer.MAX_VALUE);
        }
    }

### Client ###

import java.net.InetSocketAddress;
    import java.nio.ByteBuffer;
    import java.nio.channels.AsynchronousSocketChannel;
    
    public class Client {
        
    
        public static void main(String[] args) throws Exception {
        
        	// 创建 Client
            AsynchronousSocketChannel socketChannel = AsynchronousSocketChannel.open();
            // 与 Server 连接
            socketChannel.connect(new InetSocketAddress("127.0.0.1", 8000)).get();
    		
    		// 向 Server 写数据
            socketChannel.write(ByteBuffer.wrap("HelloServer".getBytes()));
    		
    		// 读取 Server 的数据
            ByteBuffer buffer = ByteBuffer.allocate(512);
            Integer len = socketChannel.read(buffer).get();
            if (len != -1) {
        
                System.out.println("客户端收到消息：" + new String(buffer.array(), 0, len));
            }
    
    		// 持续阻塞，看AIO能否同时处理多个连接
            Thread.sleep(Integer.MAX_VALUE);
        }
    }

结果如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzkzNTkyNw_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/2847bdc5442f452d976e159089daa0a6.png