如何通过一次阻塞调用读取多个InputStream，避免轮询？

Java标准库没有直接提供你想要的select(InputStream...)这类方法，但可以借助NIO的Selector机制实现类似的阻塞逻辑——它能同时监听多个通道的可读事件，直到其中一个有数据时才返回，完全避免轮询。

核心思路 #

传统IO的InputStream无法直接被Selector监听，需要先将其转换为NIO的ReadableByteChannel，然后注册到Selector上监听OP_READ事件。当任意通道有数据可读时，selector.select()会解除阻塞，返回就绪的通道。

代码示例 #

下面是适配你需求的完整实现，包含将字节流转换为行读取的逻辑：

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

public class MultiStreamSelector {
    public static void main(String[] args) throws IOException {
        // 假设k、k2是你的原始输入流来源（比如Process的getInputStream()）
        InputStream stream1 = k.getInputStream();
        InputStream stream2 = k2.getInputStream();

        // 将InputStream转换为NIO通道
        ReadableByteChannel channel1 = Channels.newChannel(stream1);
        ReadableByteChannel channel2 = Channels.newChannel(stream2);

        // 创建Selector并注册通道
        Selector selector = Selector.open();
        channel1.register(selector, SelectionKey.OP_READ, new LineBuffer());
        channel2.register(selector, SelectionKey.OP_READ, new LineBuffer());

        try {
            while (true) {
                // 阻塞等待，直到至少一个通道就绪
                int readyChannels = selector.select();
                if (readyChannels == 0) continue;

                // 遍历所有就绪的通道
                Set<SelectionKey> selectedKeys = selector.selectedKeys();
                Iterator<SelectionKey> keyIterator = selectedKeys.iterator();

                while (keyIterator.hasNext()) {
                    SelectionKey key = keyIterator.next();

                    if (key.isReadable()) {
                        ReadableByteChannel channel = (ReadableByteChannel) key.channel();
                        LineBuffer lineBuffer = (LineBuffer) key.attachment();
                        readLinesFromChannel(channel, lineBuffer);
                    }

                    // 必须移除已处理的key，否则会重复处理
                    keyIterator.remove();
                }
            }
        } finally {
            selector.close();
            channel1.close();
            channel2.close();
        }
    }

    // 辅助类：维护缓冲区，实现按行读取
    private static class LineBuffer {
        private final ByteBuffer buffer = ByteBuffer.allocate(1024);
        private final StringBuilder lineBuilder = new StringBuilder();
    }

    // 从通道读取数据，解析为行并输出
    private static void readLinesFromChannel(ReadableByteChannel channel, LineBuffer lineBuffer) throws IOException {
        ByteBuffer buffer = lineBuffer.buffer;
        StringBuilder lineBuilder = lineBuffer.lineBuilder;

        int bytesRead = channel.read(buffer);
        if (bytesRead == -1) {
            // 通道已关闭，输出剩余内容
            if (lineBuilder.length() > 0) {
                System.out.println("[+] " + lineBuilder);
            }
            channel.close();
            return;
        }

        // 切换为读模式
        buffer.flip();
        while (buffer.hasRemaining()) {
            byte b = buffer.get();
            if (b == '\n') {
                // 遇到换行符，输出整行
                System.out.println("[+] " + lineBuilder);
                lineBuilder.setLength(0);
            } else if (b != '\r') {
                // 忽略回车符，拼接字符
                lineBuilder.append((char) b);
            }
        }
        // 压缩缓冲区，准备下一次读取
        buffer.compact();
    }
}

关键说明 #

• 通道转换：通过Channels.newChannel(InputStream)将传统IO流转为NIO通道，这是实现监听的前提。
• Selector阻塞：selector.select()会一直阻塞，直到至少一个注册的通道有数据可读，完全替代轮询逻辑。
• 行读取适配：因为NIO没有直接的readLine方法，所以通过LineBuffer维护缓冲区和字符串构建器，手动解析换行符来实现按行输出，和你原来的BufferedReader.readLine()行为一致。
• 资源清理：记得在finally块关闭Selector和通道，避免资源泄漏。

补充说明 #

如果你的输入流来自子进程（比如Process的stdout和stderr），还有一种简化方案：用ProcessBuilder.redirectErrorStream(true)将stderr重定向到stdout，这样只需要处理一个输入流。但这种方式会混合两个流的输出，如果你需要区分来源，还是用Selector方案更合适。

内容的提问来源于stack exchange，提问作者SempriGno