Java：如何中止从 System.in 读取的线程

Question

我有一个 Java 线程：

class MyThread extends Thread {
  @Override
  public void run() {
    BufferedReader stdin =
        new BufferedReader(new InputStreamReader(System.in));
    String msg;
    try {
      while ((msg = stdin.readLine()) != null) {
        System.out.println("Got: " + msg);
      }
      System.out.println("Aborted.");
    } catch (IOException ex) {
      ex.printStackTrace();
    }
  }
}

}

在另一个线程中，如何中止该线程中的stdin.readline() 调用，以便该线程打印Aborted.？我试过System.in.close()，但这没有任何区别，stdin.readline() 仍然阻塞。

我对没有的解决方案感兴趣

• 忙等待（因为这会消耗 100% CPU）；
• 正在睡觉（因为那时程序不会立即响应System.in）。

Answer 1

Heinz Kabutz's newsletter 显示如何中止System.in 读取：

import java.io.*;
import java.util.concurrent.*;

class ConsoleInputReadTask implements Callable<String> {
  public String call() throws IOException {
    BufferedReader br = new BufferedReader(
        new InputStreamReader(System.in));
    System.out.println("ConsoleInputReadTask run() called.");
    String input;
    do {
      System.out.println("Please type something: ");
      try {
        // wait until we have data to complete a readLine()
        while (!br.ready()) {
          Thread.sleep(200);
        }
        input = br.readLine();
      } catch (InterruptedException e) {
        System.out.println("ConsoleInputReadTask() cancelled");
        return null;
      }
    } while ("".equals(input));
    System.out.println("Thank You for providing input!");
    return input;
  }
}

public class ConsoleInput {
  private final int tries;
  private final int timeout;
  private final TimeUnit unit;

  public ConsoleInput(int tries, int timeout, TimeUnit unit) {
    this.tries = tries;
    this.timeout = timeout;
    this.unit = unit;
  }

  public String readLine() throws InterruptedException {
    ExecutorService ex = Executors.newSingleThreadExecutor();
    String input = null;
    try {
      // start working
      for (int i = 0; i < tries; i++) {
        System.out.println(String.valueOf(i + 1) + ". loop");
        Future<String> result = ex.submit(
            new ConsoleInputReadTask());
        try {
          input = result.get(timeout, unit);
          break;
        } catch (ExecutionException e) {
          e.getCause().printStackTrace();
        } catch (TimeoutException e) {
          System.out.println("Cancelling reading task");
          result.cancel(true);
          System.out.println("\nThread cancelled. input is null");
        }
      }
    } finally {
      ex.shutdownNow();
    }
    return input;
  }
}

现在，我不知道这种方法是否泄漏、不可移植或有任何不明显的副作用。就个人而言，我不愿意使用它。

你也许可以用 NIO channels 和 file descriptors 做点什么——我自己对它们的实验没有产生任何结果。

Answer 2

怎么样...

private static BufferedReader stdInCh = new BufferedReader(
    new InputStreamReader(Channels.newInputStream((
    new FileInputStream(FileDescriptor.in)).getChannel())));

调用stdInch.readline() 的线程现在可中断，readline() 将抛出java.nio.channels.ClosedByInterruptException。

Answer 3

我的第一反应是 线程 和 System.in 真的不在一起。

首先，将其拆分，以便线程代码不会触及任何静态，包括System.in。

一个线程从InputStream 读取数据并传递到一个缓冲区。将InputStream 传递到从缓冲区读取的现有线程中，但还会检查您是否没有中止。

Answer 4

JavaDoc for BufferedReader.readLine:

返回： 包含行内容的字符串，不包括任何内容 行终止字符，或 null 如果流的结尾已经 到达

基于此，我认为它永远不会返回 null（System.in 实际上可以关闭吗，我认为它永远不会返回流的结尾？），所以 while 循环不会终止.停止线程的常用方法是在循环条件中使用布尔变量并从线程外部更改它或调用线程对象的 interrupt() -方法（仅在线程处于 wait() 时才有效：ing 或sleep():ing，或在抛出 InterruptedException 的阻塞方法中）。也可以用isInterrupted()检查线程是否被中断。

编辑：这是一个使用isInterrupted() 和interrupt() 的简单实现。主线程在中断工作线程之前等待 5 秒。在这种情况下，工作线程基本上是忙于等待，所以它不是那么好（一直循环并检查stdin.ready()，如果没有输入准备好，你当然可以让工作线程休眠一段时间）：

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;


public class MyThreadTest
{
    public static void main(String[] args)
    {
        MyThread myThread = new MyThread();
        myThread.start();

        try
        {
            Thread.sleep(5000);
        }
        catch(InterruptedException e)
        {
            //Do nothing
        }

        myThread.interrupt();

    }

    private static class MyThread extends Thread
    {       
        @Override
        public void run()
        {
            BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));
            String msg;

            while(!isInterrupted())
            {
                try
                {
                    if(stdin.ready())
                    {
                        msg = stdin.readLine();
                        System.out.println("Got: " + msg);
                    }
                }
                catch(IOException e)
                {
                    e.printStackTrace();
                }
            }           
            System.out.println("Aborted.");
        }
    }

}

如果 BufferedReader 在 readline 上被阻塞，似乎没有办法真正中断它，或者至少我找不到（使用 System.in）。

Answer 5

InputStream 永远不能抛出 InterruptedException 因为它不在它的合同中。 （你应该在阅读之前继续检查available。）事实上，大多数类和方法都没有这个例外！（而且在大多数情况下，他们不会打扰调用available.)

更大的问题是InterruptibleChannel（合同中确实有它）也不能保证成功。一些 Channel 谎称是可中断的，而使用这些通道的类可能会阻塞。例如，您可能认为Channels.newChannel(System.in) 会给您一个不错的InterruptibleChannel。但源代码 cmets “不是真正可中断”和“最多阻塞一次”（OpenJDK 16）证明了这是一个谎言。 （是的，它确实会阻塞，我已经检查过了。荒谬！）

我发现一个有效的组合是使用new FileInputStream(FileDescriptor.in).getChannel() 和Scanner。

Scanner scanner = new Scanner(new FileInputStream(FileDescriptor.in).getChannel())

while (!scanner.hasNextLine())
    Thread.sleep(100); // Internally checks Thread.interrupted() and throws InterruptedException

String line = scanner.nextLine()

这真的不应该是一个问题。编写一个检查System.in.available()、Thread.interrupted()、抛出InterruptedException 等的类很简单。? 如果在阻塞模式下给定InputStream 或Channel，即使扫描仪也不会检查available（如OpenJDK 16)。如果您知道有一个理智的课程，请发表评论。

Answer 6

关于在上面的线程类定义中定义一个字段，例如：

class MyThread extends Thread {   

  protected AtomicBoolean abortThread = new AtomicBoolean(false);

  public void doAbort()
  {
    this.abortThread.set(true);
  }

  @Override   public void run() 
  { 
    ...
    if (this.abortThread.get())
    {
      ...something like break loop...
    }
  }
}