【Java】网络通信IO模型

Java网络编程中的IO（Input/Output）模型是管理计算机对外部数据读取和写入操作的重要机制。Java提供了多种IO模型来满足不同的网络通信需求。

一、阻塞IO（BIO，Blocking I/O）

概念：
- 阻塞IO是最简单和直观的一种IO模型。在BIO模型中，当用户线程发起系统调用时，内核会一直等待，直到有数据可读或可写，才会返回结果。
特点：
- 同步阻塞：服务器实现模式为一个连接一个线程，即客户端有连接请求时，服务器端就需要启动一个线程进行处理。如果这个连接不做任何事情，会造成不必要的线程开销。
- 简单易用：BIO模型的编程流程相对简单，容易理解和实现。
- 资源消耗大：在高并发情况下，每个线程都会阻塞，导致系统性能急剧下降，且对服务器资源要求较高。
适用场景：
- 适用于连接数目比较小且固定的架构。
- 常用于文件操作或较少并发连接的网络服务。

示例：Java传统Socket模型，线程在读写时会被阻塞。

// 客户端
try (Socket socket = new Socket("localhost", 8080);
     BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
      
      
    // 阻塞直到数据到达
    String response = in.readLine();
    System.out.println("Response: " + response);
}

// 服务端
try (ServerSocket serverSocket = new ServerSocket(8080);
     Socket clientSocket = serverSocket.accept(); // 阻塞等待连接
     PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
      
      
    out.println("Hello from blocking server!");
}

二、非阻塞IO（NIO，Non-blocking I/O）

概念：
- NIO模型允许在不阻塞当前线程的情况下发起IO操作。如果操作无法立即完成，方法会返回特定值（如0或特定错误码），而不是阻塞。
特点：
- 非阻塞模式：线程在等待IO操作完成时不会被阻塞，可以继续执行其他任务。
- 高效利用资源：通过减少线程的阻塞等待时间，提高了系统资源的利用率。
- 需要轮询：由于非阻塞IO不会主动通知线程操作完成，因此需要线程反复检查或轮询IO操作的状态。
核心组件：
- Channel（通道）：表示打开到IO设备（如文件、套接字）的连接，支持非阻塞读取和写入。
- Buffer（缓冲区）：用于存取数据的内存块，提供了方便访问该块内存的方法。
- Selector（选择器）：能够检查一个或多个NIO通道，并确定哪些通道已经准备好进行读取或写入。
适用场景：
- 适用于连接数目多且连接时间较短的架构，如聊天服务器、弹幕系统等。

示例：多人聊天室

服务端

package com.example.helloword;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

/**
 * 服务端功能
 *  监听新连接：通过 ServerSocketChannel 接受客户端连接，并注册到 Selector。
 *  处理消息：读取客户端消息并广播给其他用户。
 *  上下线通知：当客户端连接或断开时，广播通知所有用户。
 *  异常处理：检测客户端异常断开并清理资源。
 */
public class GroupChatServer {
        
        
    private static final int PORT = 6667;
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;

    public GroupChatServer() {
        
        
        try {
        
        
            selector = Selector.open();
            serverSocketChannel = ServerSocketChannel.open();
            serverSocketChannel.socket().bind(new InetSocketAddress(PORT));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            System.out.println("服务器启动，监听端口：" + PORT);
        } catch (IOException e) {
        
        
            e.printStackTrace();
        }
    }

    public void listen() {
        
        
        try {
        
        
            while (true) {
        
        
                selector.select();
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
        
        
                    SelectionKey key = iterator.next();
                    iterator.remove(); // 防止重复处理

                    if (key.isAcceptable()) {
        
        
                        handleAccept(key);
                    } else if (key.isReadable()) {
        
        
                        handleRead(key);
                    }
                }
            }
        } catch (IOException e) {
        
        
            e.printStackTrace();
        }
    }

    private void handleAccept(SelectionKey key) throws IOException {
        
        
        SocketChannel clientChannel = serverSocketChannel.accept();
        clientChannel.configureBlocking(false);
        clientChannel.register(selector, SelectionKey.OP_READ);
        String msg = "[" + clientChannel.getRemoteAddress() + "] 上线了";
        System.out.println(msg);
        broadcast(msg, clientChannel); // 广播上线通知
    }

    private void handleRead(SelectionKey key) {
        
        
        SocketChannel clientChannel = (SocketChannel) key.channel();
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        try {
        
        
            int len = clientChannel.read(buffer);
            if (len > 0) {
        
        
                String msg = new String(buffer.array(), 0, len).trim();
                System.out.println("收到消息: " + msg);
                broadcast(msg, clientChannel); // 广播消息
            } else if (len == -1) {
        
         // 客户端正常关闭
                handleDisconnect(clientChannel, "下线");
            }
        } catch (IOException e) {
        
        
            handleDisconnect(clientChannel, "异常断开");
        }
    }

    private void handleDisconnect(SocketChannel clientChannel, String reason) {
        
        
        try {
        
        
            String msg = "[" + clientChannel.getRemoteAddress() + "] " + reason;
            System.out.println(msg);
            broadcast(msg, clientChannel);
            clientChannel.close();
        } catch (IOException ex) {
        
        
            ex.printStackTrace();
        }
    }

    private void broadcast(String msg, SocketChannel excludeChannel) throws IOException {
        
        
        for (SelectionKey key : selector.keys()) {
        
        
            Channel targetChannel = key.channel();
            if (targetChannel instanceof SocketChannel && targetChannel != excludeChannel) {
        
        
                SocketChannel dest = (SocketChannel) targetChannel;
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                dest.write(buffer);
            }
        }
    }

    public static void main(String[] args) {
        
        
        new GroupChatServer().listen();
    }
}

客户端

package com.example.helloword;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Scanner;
import java.util.Set;

/**
 * 客户端功能
 *  连接服务器：初始化时自动连接服务器。
 *  发送消息：读取用户输入并发送到服务器。
 *  接收消息：监听服务器广播的消息并实时显示。
 *  退出机制：输入 exit 退出群聊并关闭连接。
 */
public class GroupChatClient {
        
        
    private static final String HOST = "127.0.0.1";
    private static final int PORT = 6667;
    private SocketChannel socketChannel;
    private Selector selector;
    private String username;

    public GroupChatClient() {
        
        
        try {
        
        
            selector = Selector.open();
            socketChannel = SocketChannel.open(new InetSocketAddress(HOST, PORT));
            socketChannel.configureBlocking(false);
            socketChannel.register(selector, SelectionKey.OP_READ);
            username = "用户" + socketChannel.getLocalAddress().toString().substring(1).replaceAll("[:.]", "");
            System.out.println(username + " 已连接到服务器");
        } catch (IOException e) {
        
        
            e.printStackTrace();
        }
    }

    public void sendMsg(String msg) {
        
        
        if ("exit".equalsIgnoreCase(msg)) {
        
        
            try {
        
        
                socketChannel.close();
                selector.close();
                System.out.println("已退出群聊");
                System.exit(0);
            } catch (IOException e) {
        
        
                e.printStackTrace();
            }
            return;
        }
        try {
        
        
            String formattedMsg = username + ": " + msg;
            ByteBuffer buffer = ByteBuffer.wrap(formattedMsg.getBytes());
            socketChannel.write(buffer);
        } catch (IOException e) {
        
        
            e.printStackTrace();
        }
    }

    public void readMsg() {
        
        
        try {
        
        
            while (true) {
        
        
                selector.select();
                System.out.println("==> readMsg");
                Set<SelectionKey> keys = selector.selectedKeys();
                for (SelectionKey key : keys) {
        
        
                    if (key.isReadable()) {
        
        
                        SocketChannel channel = (SocketChannel) key.channel();
                        ByteBuffer buffer = ByteBuffer.allocate(1024);
                        int len = channel.read(buffer);
                        if (len > 0) {
        
        
                            String msg = new String(buffer.array(), 0, len).trim();
                            System.out.println(msg);
                        } else if (len == -1) {
        
        
                            System.out.println("服务端已关闭连接");
                            key.cancel();       // 取消 SelectionKey 的注册
                            channel.close();    // 关闭通道
                            System.exit(0);
                        }
                    }
                }
                keys.clear();
            }
        } catch (IOException e) {
        
        
            System.out.println("与服务器断开连接");
            System.exit(0);
        } finally {
        
        
            // 关闭资源
            try {
        
        
                if (socketChannel != null) socketChannel.close();
                if (selector != null) selector.close();
            } catch (IOException ex) {
        
        
                ex.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        
        
        GroupChatClient client = new GroupChatClient();
        // 启动线程监听服务器消息
        new Thread(client::readMsg).start();

        // 读取用户输入并发送
        Scanner scanner = new Scanner(System.in);
        while (true) {
        
        
            String msg = scanner.nextLine();
            client.sendMsg(msg);
        }

    }
}

允许开启多个客户端：(IDEA 2024)
- Edit Confihurations
- Modify option --> Allow multiple instance

三、异步IO（AIO，Asynchronous I/O）

概念：
- AIO模型允许在发起IO操作后不阻塞线程，并且在操作完成时通过回调或未来（Future）来通知应用程序。
特点：
- 异步操作：发起IO操作后立即返回，操作在后台进行，不会阻塞线程。
- 回调通知：操作完成后，通过回调或Future通知应用程序，进一步减少了线程的阻塞。
- 编程复杂：相比BIO和NIO，AIO的编程模型更为复杂。
  适用场景：
- 适用于连接数目多且连接时间较长的架构，如相册服务器等。

AsynchronousServerSocketChannel server = AsynchronousServerSocketChannel.open();
server.bind(new InetSocketAddress(8080));
server.accept(null, new CompletionHandler<AsynchronousSocketChannel, Void>() {
    
    
    @Override
    public void completed(AsynchronousSocketChannel client, Void attachment) {
    
    
        server.accept(null, this); // 继续接收新连接
        ByteBuffer buffer = ByteBuffer.allocate(1024);
        client.read(buffer, buffer, new CompletionHandler<Integer, ByteBuffer>() {
    
    
            @Override
            public void completed(Integer result, ByteBuffer buffer) {
    
    
                // 处理读取的数据
            }
        });
    }
});

四、总结

模型	BIO	NIO	AIO
阻塞性	同步阻塞	同步非阻塞	异步非阻塞
线程模型	1 连接 1 线程	多路复用（单线程/线程池）	回调驱动
复杂度	低	中高	高
适用场景	低并发、简单应用	高并发、实时响应（如 Netty）	特定场景（如文件操作）
接口	Socket ServerSocket	SocketChanne ServerSocketChannel	AsynchronousSocketChannel AsynchronousServerSocketChannel

实践建议：

BIO：仅用于教学或低负载场景。
NIO：大多数高并发场景的首选，结合 Netty 等框架简化开发。
AIO：谨慎使用，需评估操作系统支持与业务需求。

为什么主流框架（如 Netty）选择 NIO 而非 AIO？

NIO 的成熟度高，跨平台兼容性好。
Linux 的 AIO 实现不完全（如文件 AIO 稳定，网络 AIO 依赖线程池）。
NIO 通过优化（如 epoll 边缘触发）已能支撑百万级并发。

一、阻塞IO（BIO，Blocking I/O）

二、非阻塞IO（NIO，Non-blocking I/O）

三、异步IO（AIO，Asynchronous I/O）

四、总结

猜你喜欢

目录

热门文章