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 的新闻通讯展示了如何中止 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 通道 和 文件描述符 - 我自己对它们的实验没有产生任何结果。

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

InputStream 永远不会抛出 InterruptedException，因为它不在其契约中。 （在阅读之前，您应该不断检查available。）事实上，该异常不在大多数类和方法的约定中！（而且在大多数情况下，它们不必费心调用 available。）

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

我发现有效的组合是将 new FileInputStream(FileDescriptor.in).getChannel() 与 一起使用扫描仪。

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 等的类很简单。

Answer 4

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

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

线程从 InputStream 读取数据并传入缓冲区。将 InputStream 传递到现有线程中，该线程从缓冲区读取数据，同时检查您是否尚未中止。

Answer 5

BufferedReader.readLine 的 JavaDoc ：

返回：
包含该行内容的字符串，不包括任何内容
行终止字符，或 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），那么似乎没有办法真正中断 BufferedReader。

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...
    }
  }
}