java如何使用 NIO 进行高效的 IO 操作 javaNIO 高效操作的基础教程技巧​

selector.select()

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.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NioEchoServer {

    public static void main(String[] args) throws IOException {
        // 1. 打开一个ServerSocketChannel，用于监听客户端连接
        ServerSocketChannel serverChannel = ServerSocketChannel.open();
        // 2. 设置为非阻塞模式
        serverChannel.configureBlocking(false);
        // 3. 绑定监听端口
        serverChannel.socket().bind(new InetSocketAddress(8080));

        // 4. 打开一个选择器
        Selector selector = Selector.open();
        // 5. 将ServerSocketChannel注册到选择器上，并监听OP_ACCEPT事件
        // 意思就是：当有新的客户端连接进来时，选择器会通知我
        serverChannel.register(selector, SelectionKey.OP_ACCEPT);

        System.out.println("Echo服务器已启动，监听端口 8080...");

        // 6. 循环等待I/O事件
        while (true) {
            // select()方法会阻塞，直到至少有一个注册的事件发生
            // 返回值是已就绪的事件数量
            int readyChannels = selector.select();

            // 如果没有事件发生，继续循环
            if (readyChannels == 0) {
                continue;
            }

            // 7. 获取所有已就绪的SelectionKey
            Set<SelectionKey> selectedKeys = selector.selectedKeys();
            Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

            while (keyIterator.hasNext()) {
                SelectionKey key = keyIterator.next();
                // 处理完一个事件后，需要从集合中移除，否则下次还会被处理
                keyIterator.remove();

                try {
                    // 8. 根据事件类型进行处理
                    if (key.isAcceptable()) {
                        // 有新的连接请求
                        handleAccept(key, selector);
                    } else if (key.isReadable()) {
                        // 通道有数据可读
                        handleRead(key);
                    }
                    // 还可以处理isWritable(), isConnectable()等事件
                } catch (IOException e) {
                    // 客户端断开连接或发生其他I/O错误
                    System.err.println("客户端连接异常或断开: " + e.getMessage());
                    key.cancel(); // 取消这个键，不再监听其事件
                    try {
                        key.channel().close(); // 关闭通道
                    } catch (IOException ioe) {
                        // ignore
                    }
                }
            }
        }
    }

    private static void handleAccept(SelectionKey key, Selector selector) throws IOException {
        ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
        // 接受客户端连接
        SocketChannel clientChannel = serverChannel.accept();
        clientChannel.configureBlocking(false); // 同样设置为非阻塞

        // 将客户端通道注册到选择器上，并监听OP_READ事件
        // 意思是：当客户端有数据发过来时，选择器会通知我
        clientChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024)); // 附加一个缓冲区
        System.out.println("接受新连接来自: " + clientChannel.getRemoteAddress());
    }

    private static void handleRead(SelectionKey key) throws IOException {
        SocketChannel clientChannel = (SocketChannel) key.channel();
        // 获取之前附加的缓冲区
        ByteBuffer buffer = (ByteBuffer) key.attachment();
        buffer.clear(); // 清空缓冲区，准备写入数据

        int bytesRead = clientChannel.read(buffer); // 从通道读取数据到缓冲区

        if (bytesRead == -1) {
            // 客户端已关闭连接
            System.out.println("客户端断开连接: " + clientChannel.getRemoteAddress());
            key.cancel();
            clientChannel.close();
        } else if (bytesRead > 0) {
            buffer.flip(); // 切换到读模式，准备从缓冲区读取数据
            System.out.println("从 " + clientChannel.getRemoteAddress() + " 收到数据: " + new String(buffer.array(), 0, buffer.limit()));

            // 将数据写回客户端
            while (buffer.hasRemaining()) {
                clientChannel.write(buffer);
            }
            // 此时buffer.position() == buffer.limit()，缓冲区已读完
            // 下次再读时，会重新clear，然后从头开始写
        }
    }
}

ByteBuffer

read()

write()