如果我开始阅读System.in ，它会阻止线程，直到它得到的数据。 有没有办法阻止它。 下面是我试过的所有方式：
- 中断线程
- 停止线
- 关闭
System.in - 调用
System.exit(0)确实停止线程，但它也杀死了我的应用程序，以便不理想。 - 输入一个字符到控制台使得该方法返回，但我不能依靠用户输入。
示例代码不工作：
public static void main(String[] args) throws InterruptedException {
Thread th = new Thread(() -> {
try {
System.in.read();
} catch (IOException e) {
e.printStackTrace();
}
});
th.start();
Thread.sleep(1000);
System.in.close();
Thread.sleep(1000);
th.interrupt();
Thread.sleep(1000);
th.stop();
Thread.sleep(1000);
System.out.println(th.isAlive()); // Outputs true
}
当我运行这段代码，它将输出true和永远运行。
如何从读System.in以中断方式？
您应该设计的run方法，以便它可以自行确定何时终止。 调用stop（）或于螺纹类似的方法将是固有的不安全性 。
但是，仍然存在如何避免内部System.in.read阻塞的问题？ 要做到这一点，你可以轮询System.in.available直到它读取之前返回> 0。
示例代码：
Thread th = new Thread(() -> {
try {
while(System.in.available() < 1) {
Thread.sleep(200);
}
System.in.read();
} catch (InterruptedException e) {
// sleep interrupted
} catch (IOException e) {
e.printStackTrace();
}
});
当然，这通常被认为是有利的是使用一个阻塞IO方法而不是轮询。 但是轮询确实有它的用途; 在您的情况，它可以让这个线程完全退出。
一个更好的办法：
一个更好的方法 ，避免投票将是重组的代码，以便您打算杀死任何线程不允许直接访问System.in 。 这是因为System.in是一个不应被关闭的InputStream。 代替主线程或另一个专用线程将从System.in（阻挡）读然后写任何内容到缓冲区中。 该缓冲区，反过来，将由您打算杀死线程监视。
示例代码：
public static void main(String[] args) throws InterruptedException, IOException {
PipedOutputStream stagingPipe = new PipedOutputStream();
PipedInputStream releasingPipe = new PipedInputStream(stagingPipe);
Thread stagingThread = new Thread(() -> {
try {
while(true) {
stagingPipe.write(System.in.read());
}
} catch (IOException e) {
e.printStackTrace();
}
});
stagingThread.setDaemon(true);
stagingThread.start();
Thread th = new Thread(() -> {
try {
releasingPipe.read();
} catch (InterruptedIOException e) {
// read interrupted
} catch (IOException e) {
e.printStackTrace();
}
});
th.start();
Thread.sleep(1000);
Thread.sleep(1000);
th.interrupt();
Thread.sleep(1000);
Thread.sleep(1000);
System.out.println(th.isAlive()); // Outputs false
}
我写了一个包装的InputStream类，允许被打断：
package de.piegames.voicepi.stt;
import java.io.IOException;
import java.io.InputStream;
public class InterruptibleInputStream extends InputStream {
protected final InputStream in;
public InterruptibleInputStream(InputStream in) {
this.in = in;
}
/**
* This will read one byte, blocking if needed. If the thread is interrupted while reading, it will stop and throw
* an {@link IOException}.
*/
@Override
public int read() throws IOException {
while (!Thread.interrupted())
if (in.available() > 0)
return in.read();
else
Thread.yield();
throw new IOException("Thread interrupted while reading");
}
/**
* This will read multiple bytes into a buffer. While reading the first byte it will block and wait in an
* interruptable way until one is available. For the remaining bytes, it will stop reading when none are available
* anymore. If the thread is interrupted, it will return -1.
*/
@Override
public int read(byte b[], int off, int len) throws IOException {
if (b == null) {
throw new NullPointerException();
} else if (off < 0 || len < 0 || len > b.length - off) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return 0;
}
int c = -1;
while (!Thread.interrupted())
if (in.available() > 0) {
c = in.read();
break;
} else
Thread.yield();
if (c == -1) {
return -1;
}
b[off] = (byte) c;
int i = 1;
try {
for (; i < len; i++) {
c = -1;
if (in.available() > 0)
c = in.read();
if (c == -1) {
break;
}
b[off + i] = (byte) c;
}
} catch (IOException ee) {
}
return i;
}
@Override
public int available() throws IOException {
return in.available();
}
@Override
public void close() throws IOException {
in.close();
}
@Override
public synchronized void mark(int readlimit) {
in.mark(readlimit);
}
@Override
public synchronized void reset() throws IOException {
in.reset();
}
@Override
public boolean markSupported() {
return in.markSupported();
}
}
调整Thread.yield()只要在床上睡觉的最大延迟您能接纳和中断当一些例外准备，但，除了它应该工作的罚款。
