如何确定 BufferedReader 的确切状态？

Question

我有一个BufferedReader（由new BufferedReader(new InputStreamReader(process.getInputStream())) 生成）。我对BufferedReader 的概念很陌生，但在我看来，它具有三种状态：

1. 有一行等待读取；调用bufferedReader.readLine 将立即返回此字符串。
2. 流已打开，但没有等待读取的行；调用bufferedReader.readLine 将挂起线程，直到有一行可用。
3. 流已关闭；调用 bufferedReader.readLine 将返回 null。

现在我想确定BufferedReader 的状态，以便确定是否可以在不挂起应用程序的情况下安全地读取它。底层过程（见上文）是出了名的不可靠，因此可能已经挂起；在这种情况下，我不希望我的主机应用程序挂起。因此，我正在实施一种超时。我试着先用线程来做这件事，但它变得非常复杂。

调用BufferedReader.ready() 不会区分上述情况（2）和（3）。换句话说，如果ready() 返回 false，则可能是流刚刚关闭（换句话说，我的底层进程正常关闭）或者底层进程挂起。

所以我的问题是：如何确定我的BufferedReader 处于这三个状态中的哪一个而不实际调用readLine？不幸的是，我不能只打电话给readLine 来检查这个，因为它会打开我的应用程序。

我使用的是 JDK 1.5 版。

Answer 1

有些数据可能在缓冲区中，但不一定足以填满一行。在这种情况下，ready() 将返回 true，但调用 readLine() 会阻塞。

您应该能够轻松构建自己的 ready() 和 readLine() 方法。您的ready() 实际上会尝试建立一条线，只有当它成功完成后才会返回true。然后你的readLine() 可以返回完整的行。

Answer 2

最后我找到了解决方案。这里的大多数答案都依赖于线程，但正如我之前指定的，我正在寻找一种不需要线程的解决方案。但是，我的基础是过程。我发现如果输出（称为“输入”）和错误流都为空且关闭，进程似乎会退出。如果您考虑一下，这是有道理的。

所以我只是轮询了输出和错误流，并尝试确定进程是否已退出。以下是我的解决方案的粗略副本。

public String readLineWithTimeout(Process process, long timeout) throws IOException, TimeoutException {
  BufferedReader output = new BufferedReader(new InputStreamReader(process.getInputStream()));
  BufferedReader error = new BufferedReader(new InputStreamReader(process.getErrorStream()));
  boolean finished = false;
  long startTime = 0;
  while (!finished) {
    if (output.ready()) {
      return output.readLine();
    } else if (error.ready()) {
      error.readLine();
    } else {
      try {
        process.exitValue();
        return null;
      } catch (IllegalThreadStateException ex) {
        //Expected behaviour
      }
    }
    if (startTime == 0) {
      startTime = System.currentTimeMills();
    } else if (System.currentTimeMillis() > startTime + timeout) {
      throw new TimeoutException();
    }
  }
}

Answer 3

这是 java 的阻塞 I/O API 的一个非常基本的问题。

我怀疑你会选择以下之一：

(1) 重新审视使​​用线程的想法。这不必很复杂，正确地完成，它会让你的代码非常优雅地避开阻塞的 I/O 读取，例如：

final BufferedReader reader = ...
ExecutorService executor = // create an executor here, using the Executors factory class.
Callable<String> task = new Callable<String> {
   public String call() throws IOException {
      return reader.readLine();
   }
};
Future<String> futureResult = executor.submit(task);
String line = futureResult.get(timeout);  // throws a TimeoutException if the read doesn't return in time

(2) 使用java.nio 代替java.io。这是一个更复杂的 API，但它具有非阻塞语义。

Answer 4

您是否通过实验证实了您的断言，即使底层流位于文件末尾，ready() 也会返回 false？因为我不希望这个断言是正确的（虽然我没有做过实验）。

Answer 5

您可以使用 InputStream.available() 来查看进程是否有新的输出。如果进程只输出完整的行，这应该可以按照您想要的方式工作，但它并不真正可靠。

解决该问题的一种更可靠的方法是有一个单独的线程专门用于从进程中读取数据并将它读取的每一行推送到某个队列或消费者。

Answer 6

通常，您必须使用多个线程来实现这一点。在某些特殊情况下，例如从套接字读取，底层流具有内置的超时功能。

但是，使用多个线程执行此操作应该不会太复杂。这是我使用的模式：

private static final ExecutorService worker = 
  Executors.newSingleThreadExecutor();

private static class Timeout implements Callable<Void> {
  private final Closeable target;
  private Timeout(Closeable target) {
    this.target = target;
  }
  public Void call() throws Exception {
    target.close();
    return null;
  }
}

...

InputStream stream = process.getInputStream();
Future<?> task = worker.schedule(new Timeout(stream), 5, TimeUnit.SECONDS);
/* Use the stream as you wish. If it hangs for more than 5 seconds, 
   the underlying stream is closed, raising an IOException here. */
...
/* If you get here without timing out, cancel the asynchronous timeout 
  and close the stream explicitly. */
if(task.cancel(false))
  stream.close();

Answer 7

您可以在 InputStream 或 InputStreamReader 周围制作自己的包装器，该包装器在逐字节级别上工作，ready() 会返回准确的值。

您的其他选项是可以简单地完成的线程（查看 Java 提供的一些并发数据结构）和 NIO，这非常复杂并且可能矫枉过正。

Answer 8

如果你只是想要超时，那么这里的其他方法可能会更好。如果你想要一个非阻塞缓冲阅读器，我会这样做，使用线程：（请注意我没有测试过这个，至少它需要添加一些异常处理）

public class MyReader implements Runnable {
    private final BufferedReader reader;
    private ConcurrentLinkedQueue<String> queue = new ConcurrentLinkedQueue<String>();
    private boolean closed = false;

    public MyReader(BufferedReader reader) {
        this.reader = reader;
    }

    public void run() {
        String line;
        while((line = reader.readLine()) != null) {
            queue.add(line);
        }
        closed = true;
    }

    // Returns true iff there is at least one line on the queue
    public boolean ready() {
        return(queue.peek() != null);
    }

    // Returns true if the underlying connection has closed
    // Note that there may still be data on the queue!
    public boolean isClosed() {
        return closed;
    }

    // Get next line
    // Returns null if there is none
    // Never blocks
    public String readLine() {
        return(queue.poll());
    }
}

使用方法如下：

BufferedReader b; // Initialise however you normally do
MyReader reader = new MyReader(b);
new Thread(reader).start();

// True if there is data to be read regardless of connection state
reader.ready();

// True if the connection is closed
reader.closed();

// Gets the next line, never blocks
// Returns null if there is no data
// This doesn't necessarily mean the connection is closed, it might be waiting!
String line = reader.readLine(); // Gets the next line

有四种可能的状态：

1. 连接已打开，没有可用数据
2. 连接已打开，数据可用
3. 连接已关闭，数据可用
4. 连接已关闭，没有可用数据

您可以使用 isClosed() 和 ready() 方法区分它们。