Как определить точное состояние BufferedReader?

существует состояние, в котором некоторые данные могут находиться в буфере, но не обязательно достаточно для заполнения строки. В этом случае ready() вернутся true, а вызов readLine() будет блокировать.

вы должны легко быть в состоянии построить свой собственный ready() и readLine() методы. Ваш ready() фактически попытается создать линию, и только когда это будет сделано так успешно, она вернется true. Тогда ваш readLine() может вернуть полностью сформированной линии.

Это довольно фундаментальная проблема с блокировкой API ввода-вывода java.

Я подозреваю, что вы захотите выбрать один из:

(1) повторно посетите идею использования резьбы. Это не должно быть сложным, сделано правильно, и это позволит вашему коду избежать заблокированного ввода-вывода, прочитанного довольно изящно, например:

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, но он имеет неблокирующую семантику.

вы подтвердили экспериментально свое утверждение, что ready () вернет false, даже если базовый поток находится в конце файла? Потому что я не ожидал бы, что это утверждение будет правильным (хотя я не проводил эксперимент).

вы можете использовать InputStream.available (), чтобы увидеть, есть ли новый вывод из процесса. Это должно работать так, как вы хотите, если процесс выводит только полные строки, но это не очень надежно.

более надежным подходом к проблеме было бы иметь отдельный поток, предназначенный для чтения из процесса и нажатия каждой строки, которую он читает, на какую-либо очередь или потребителя.

В общем, вы должны реализовать это с несколькими потоками. Есть особые случаи, такие как чтение из сокета, где базовый поток имеет встроенный тайм-аут.

однако это не должно быть ужасно сложно сделать с несколькими потоками. Это шаблон, который я использую:

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();

вы можете создать свою собственную оболочку вокруг InputStream или InputStreamReader, которая работает на байтовом уровне, для которого ready() возвращает точные значения.

ваши другие варианты потоковой передачи, которые могут быть сделаны просто (посмотрите на некоторые из параллельных структур данных, предлагаемых Java) и NIO, что очень сложно и, вероятно, излишне.

Если вы просто хотите timeout, то другие методы здесь, возможно, лучше. Если вы хотите неблокирующий буферизованный читатель, вот как я бы это сделал, с потоками: (обратите внимание, что я не тестировал это и, по крайней мере, ему нужна некоторая обработка исключений)

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 ().