具体来说，问题是要写一个这样的方法：
int maybeRead(InputStream in, long timeout)
如果数据在 'timeout' 毫秒内可用，则返回值与 in.read() 相同，否则返回 -2。在方法返回之前，任何衍生的线程都必须退出。
为了避免争论，这里的主题是 java.io.InputStream，由 Sun（任何 Java 版本）记录。请注意，这并不像看起来那么简单。以下是 Sun 文档直接支持的一些事实。
in.read() 方法可能是不可中断的。
将 InputStream 包装在 Reader 或 InterruptibleChannel 中没有帮助，因为所有这些类都可以调用 InputStream 的方法。如果可以使用这些类，就可以编写一个直接在 InputStream 上执行相同逻辑的解决方案。
in.available() 返回 0 总是可以接受的。
in.close() 方法可能会阻塞或什么都不做。
没有一般的方法可以杀死另一个线程。
使用 inputStream.available()
System.in.available() 返回 0 总是可以接受的。
我发现相反 - 它总是返回可用字节数的最佳值。Javadoc 用于InputStream.available()：
Returns an estimate of the number of bytes that can be read (or skipped over)
from this input stream without blocking by the next invocation of a method for
this input stream.
由于时间/陈旧性，估计是不可避免的。这个数字可能是一次性的低估，因为新数据不断出现。然而，它总是在下一次呼叫时“赶上”——它应该考虑所有到达的数据，除了在新呼叫时到达的数据。当有数据不满足上述条件时，永久返回 0。
第一个警告： InputStream 的具体子类负责 available()
InputStream是一个抽象类。它没有数据源。拥有可用数据对它来说毫无意义。因此，javadoc foravailable()还指出：
The available method for class InputStream always returns 0.
This method should be overridden by subclasses.
实际上，具体的输入流类确实会覆盖 available()，提供有意义的值，而不是常量 0。
第二个警告：确保在 Windows 中输入时使用回车。
如果使用System.in，您的程序仅在您的命令外壳移交时接收输入。如果您使用文件重定向/管道（例如 somefile > java myJavaApp 或 somecommand | java myJavaApp ），则输入数据通常会立即移交。但是，如果您手动键入输入，则可能会延迟数据交接。例如，使用 windows cmd.exe shell，数据在 cmd.exe shell 中缓冲。数据仅在回车（control-m 或<enter>）之后传递给正在执行的 java 程序。这是执行环境的限制。当然，只要 shell 缓冲数据， InputStream.available() 就会返回 0 - 这是正确的行为；那时没有可用的数据。一旦数据从 shell 中可用，该方法就会返回一个 > 0 的值。注意：Cygwin 使用 cmd。
只需使用这个：
byte[] inputData = new byte[1024];
int result = is.read(inputData, 0, is.available());
// result will indicate number of bytes read; -1 for EOF with no data read.
或等效地，
BufferedReader br = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1")),1024);
// ...
// inside some iteration / processing logic:
if (br.ready()) {
int readCount = br.read(inputData, bufferOffset, inputData.length-bufferOffset);
}
声明：
public static int readInputStreamWithTimeout(InputStream is, byte[] b, int timeoutMillis)
throws IOException {
int bufferOffset = 0;
long maxTimeMillis = System.currentTimeMillis() + timeoutMillis;
while (System.currentTimeMillis() < maxTimeMillis && bufferOffset < b.length) {
int readLength = java.lang.Math.min(is.available(),b.length-bufferOffset);
// can alternatively use bufferedReader, guarded by isReady():
int readResult = is.read(b, bufferOffset, readLength);
if (readResult == -1) break;
bufferOffset += readResult;
}
return bufferOffset;
}
然后使用这个：
byte[] inputData = new byte[1024];
int readCount = readInputStreamWithTimeout(System.in, inputData, 6000); // 6 second timeout
// readCount will indicate number of bytes read; -1 for EOF with no data read.
假设您的流不受套接字支持（因此您不能使用Socket.setSoTimeout()），我认为解决此类问题的标准方法是使用 Future。
假设我有以下执行程序和流：
ExecutorService executor = Executors.newFixedThreadPool(2);
final PipedOutputStream outputStream = new PipedOutputStream();
final PipedInputStream inputStream = new PipedInputStream(outputStream);
我有编写器写入一些数据，然后等待 5 秒钟，然后再写入最后一条数据并关闭流：
Runnable writeTask = new Runnable() {
@Override
public void run() {
try {
outputStream.write(1);
outputStream.write(2);
Thread.sleep(5000);
outputStream.write(3);
outputStream.close();
} catch (Exception e) {
e.printStackTrace();
}
}
};
executor.submit(writeTask);
正常的阅读方式如下。读取将无限期地阻塞数据，因此这在 5 秒内完成：
long start = currentTimeMillis();
int readByte = 1;
// Read data without timeout
while (readByte >= 0) {
readByte = inputStream.read();
if (readByte >= 0)
System.out.println("Read: " + readByte);
}
System.out.println("Complete in " + (currentTimeMillis() - start) + "ms");
输出：
Read: 1
Read: 2
Read: 3
Complete in 5001ms
如果有更根本的问题，比如作者没有回应，读者将永远阻塞。如果我在将来包装读取，则可以按如下方式控制超时：
int readByte = 1;
// Read data with timeout
Callable<Integer> readTask = new Callable<Integer>() {
@Override
public Integer call() throws Exception {
return inputStream.read();
}
};
while (readByte >= 0) {
Future<Integer> future = executor.submit(readTask);
readByte = future.get(1000, TimeUnit.MILLISECONDS);
if (readByte >= 0)
System.out.println("Read: " + readByte);
}
输出：
Read: 1
Read: 2
Exception in thread "main" java.util.concurrent.TimeoutException
at java.util.concurrent.FutureTask$Sync.innerGet(FutureTask.java:228)
at java.util.concurrent.FutureTask.get(FutureTask.java:91)
at test.InputStreamWithTimeoutTest.main(InputStreamWithTimeoutTest.java:74)
我可以捕获 TimeoutException 并进行任何我想要的清理。
如果您的 InputStream 由 Socket 支持，您可以使用setSoTimeout设置 Socket 超时（以毫秒为单位） 。如果 read() 调用没有在指定的超时时间内解除阻塞，它将抛出 SocketTimeoutException。
只需确保在调用 read() 之前在 Socket 上调用 setSoTimeout。
我会质疑问题陈述，而不是盲目地接受它。您只需要来自控制台或网络的超时。如果您拥有后者Socket.setSoTimeout()并且HttpURLConnection.setReadTimeout()两者都完全符合要求，只要您在构建/获取它们时正确设置它们。当您所拥有的只是 InputStream 时，将其留在应用程序中的任意点是糟糕的设计，导致非常尴尬的实现。
I have not used the classes from the Java NIO package, but it seems they might be of some help here. Specifically, java.nio.channels.Channels and java.nio.channels.InterruptibleChannel.
这是一种从 System.in 获取 NIO FileChannel 并使用超时检查数据可用性的方法，这是问题中描述的问题的一种特殊情况。在控制台运行它，不要输入任何输入，然后等待结果。它在 Windows 和 Linux 上的 Java 6 下成功测试。
import java.io.FileInputStream;
import java.io.FilterInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.nio.ByteBuffer;
import java.nio.channels.ClosedByInterruptException;
public class Main {
static final ByteBuffer buf = ByteBuffer.allocate(4096);
public static void main(String[] args) {
long timeout = 1000 * 5;
try {
InputStream in = extract(System.in);
if (! (in instanceof FileInputStream))
throw new RuntimeException(
"Could not extract a FileInputStream from STDIN.");
try {
int ret = maybeAvailable((FileInputStream)in, timeout);
System.out.println(
Integer.toString(ret) + " bytes were read.");
} finally {
in.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/* unravels all layers of FilterInputStream wrappers to get to the
* core InputStream
*/
public static InputStream extract(InputStream in)
throws NoSuchFieldException, IllegalAccessException {
Field f = FilterInputStream.class.getDeclaredField("in");
f.setAccessible(true);
while( in instanceof FilterInputStream )
in = (InputStream)f.get((FilterInputStream)in);
return in;
}
/* Returns the number of bytes which could be read from the stream,
* timing out after the specified number of milliseconds.
* Returns 0 on timeout (because no bytes could be read)
* and -1 for end of stream.
*/
public static int maybeAvailable(final FileInputStream in, long timeout)
throws IOException, InterruptedException {
final int[] dataReady = {0};
final IOException[] maybeException = {null};
final Thread reader = new Thread() {
public void run() {
try {
dataReady[0] = in.getChannel().read(buf);
} catch (ClosedByInterruptException e) {
System.err.println("Reader interrupted.");
} catch (IOException e) {
maybeException[0] = e;
}
}
};
Thread interruptor = new Thread() {
public void run() {
reader.interrupt();
}
};
reader.start();
for(;;) {
reader.join(timeout);
if (!reader.isAlive())
break;
interruptor.start();
interruptor.join(1000);
reader.join(1000);
if (!reader.isAlive())
break;
System.err.println("We're hung");
System.exit(1);
}
if ( maybeException[0] != null )
throw maybeException[0];
return dataReady[0];
}
}
有趣的是，当在 NetBeans 6.5 中而不是在控制台中运行程序时，超时根本不起作用，实际上需要调用 System.exit() 来杀死僵尸线程。发生的情况是中断器线程在调用 reader.interrupt() 时阻塞 (!)。另一个测试程序（此处未显示）另外尝试关闭通道，但这也不起作用。
正如 jt 所说，NIO 是最好的（也是正确的）解决方案。如果你真的被 InputStream 困住了，你可以
生成一个线程，其唯一工作是从 InputStream 中读取并将结果放入缓冲区中，该缓冲区可以从原始线程中读取而不会阻塞。如果您只有一个流实例，这应该可以很好地工作。否则，您可以使用 Thread 类中已弃用的方法终止线程，但这可能会导致资源泄漏。
依靠 isAvailable 表示可以不阻塞读取的数据。但是，在某些情况下（例如使用 Sockets），可能需要进行一次潜在的阻塞读取，以便 isAvailable 报告 0 以外的内容。
在这个答案的启发下，我想出了一个更面向对象的解决方案。
这仅在您打算读取字符时才有效
您可以覆盖 BufferedReader 并实现如下内容：
public class SafeBufferedReader extends BufferedReader{
private long millisTimeout;
( . . . )
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
try {
waitReady();
} catch(IllegalThreadStateException e) {
return 0;
}
return super.read(cbuf, off, len);
}
protected void waitReady() throws IllegalThreadStateException, IOException {
if(ready()) return;
long timeout = System.currentTimeMillis() + millisTimeout;
while(System.currentTimeMillis() < timeout) {
if(ready()) return;
try {
Thread.sleep(100);
} catch (InterruptedException e) {
break; // Should restore flag
}
}
if(ready()) return; // Just in case.
throw new IllegalThreadStateException("Read timed out");
}
}
这是一个几乎完整的例子。
我在某些方法上返回 0，您应该将其更改为 -2 以满足您的需求，但我认为 0 更适合 BufferedReader 合同。没有发生任何错误，它只是读取了 0 个字符。readLine 方法是一个可怕的性能杀手。如果你真的想使用 readLin e ，你应该创建一个全新的 BufferedReader 。现在，它不是线程安全的。如果有人在 readLines 等待一行的时候调用了一个操作，将会产生意想不到的结果
我不喜欢在我所在的地方返回 -2。我会抛出一个异常，因为有些人可能只是在检查 int < 0 是否考虑 EOS。无论如何，这些方法声称“不能阻止”，您应该检查该语句是否真的是真的并且不要覆盖它们。
import java.io.BufferedReader;
import java.io.IOException;
import java.io.Reader;
import java.nio.CharBuffer;
import java.util.concurrent.TimeUnit;
import java.util.stream.Stream;
/**
*
* readLine
*
* @author Dario
*
*/
public class SafeBufferedReader extends BufferedReader{
private long millisTimeout;
private long millisInterval = 100;
private int lookAheadLine;
public SafeBufferedReader(Reader in, int sz, long millisTimeout) {
super(in, sz);
this.millisTimeout = millisTimeout;
}
public SafeBufferedReader(Reader in, long millisTimeout) {
super(in);
this.millisTimeout = millisTimeout;
}
/**
* This is probably going to kill readLine performance. You should study BufferedReader and completly override the method.
*
* It should mark the position, then perform its normal operation in a nonblocking way, and if it reaches the timeout then reset position and throw IllegalThreadStateException
*
*/
@Override
public String readLine() throws IOException {
try {
waitReadyLine();
} catch(IllegalThreadStateException e) {
//return null; //Null usually means EOS here, so we can't.
throw e;
}
return super.readLine();
}
@Override
public int read() throws IOException {
try {
waitReady();
} catch(IllegalThreadStateException e) {
return -2; // I'd throw a runtime here, as some people may just be checking if int < 0 to consider EOS
}
return super.read();
}
@Override
public int read(char[] cbuf) throws IOException {
try {
waitReady();
} catch(IllegalThreadStateException e) {
return -2; // I'd throw a runtime here, as some people may just be checking if int < 0 to consider EOS
}
return super.read(cbuf);
}
@Override
public int read(char[] cbuf, int off, int len) throws IOException {
try {
waitReady();
} catch(IllegalThreadStateException e) {
return 0;
}
return super.read(cbuf, off, len);
}
@Override
public int read(CharBuffer target) throws IOException {
try {
waitReady();
} catch(IllegalThreadStateException e) {
return 0;
}
return super.read(target);
}
@Override
public void mark(int readAheadLimit) throws IOException {
super.mark(readAheadLimit);
}
@Override
public Stream<String> lines() {
return super.lines();
}
@Override
public void reset() throws IOException {
super.reset();
}
@Override
public long skip(long n) throws IOException {
return super.skip(n);
}
public long getMillisTimeout() {
return millisTimeout;
}
public void setMillisTimeout(long millisTimeout) {
this.millisTimeout = millisTimeout;
}
public void setTimeout(long timeout, TimeUnit unit) {
this.millisTimeout = TimeUnit.MILLISECONDS.convert(timeout, unit);
}
public long getMillisInterval() {
return millisInterval;
}
public void setMillisInterval(long millisInterval) {
this.millisInterval = millisInterval;
}
public void setInterval(long time, TimeUnit unit) {
this.millisInterval = TimeUnit.MILLISECONDS.convert(time, unit);
}
/**
* This is actually forcing us to read the buffer twice in order to determine a line is actually ready.
*
* @throws IllegalThreadStateException
* @throws IOException
*/
protected void waitReadyLine() throws IllegalThreadStateException, IOException {
long timeout = System.currentTimeMillis() + millisTimeout;
waitReady();
super.mark(lookAheadLine);
try {
while(System.currentTimeMillis() < timeout) {
while(ready()) {
int charInt = super.read();
if(charInt==-1) return; // EOS reached
char character = (char) charInt;
if(character == '\n' || character == '\r' ) return;
}
try {
Thread.sleep(millisInterval);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // Restore flag
break;
}
}
} finally {
super.reset();
}
throw new IllegalThreadStateException("readLine timed out");
}
protected void waitReady() throws IllegalThreadStateException, IOException {
if(ready()) return;
long timeout = System.currentTimeMillis() + millisTimeout;
while(System.currentTimeMillis() < timeout) {
if(ready()) return;
try {
Thread.sleep(millisInterval);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // Restore flag
break;
}
}
if(ready()) return; // Just in case.
throw new IllegalThreadStateException("read timed out");
}
}