java - 如果在过去15秒钟内在System.in上没有输入，如何使一个线程超时

Question

我需要让线程监听system.in，并连接所有输入，并且在执行某个命令或10秒钟没有输入时，它需要运行另一个将使用收集的信息的线程。
为了清楚起见，每次输入数据时，我都需要重置10秒。
作为并发编程的初学者，我不太确定如何解决这个问题

Answer 1

欢迎使用StackOverflow！

实现要求的一种简单方法是schedule扫描命令，然后等待相应的Future返回结果或引发异常，同时等待一段时间。扫描命令是指Callable，它将从System.in变为scan the next line。

在这种情况下，您将不需要使用手工Thread处理复杂的多线程。只需创建一个合适的ExecutorService（通过使用Executors类中的相应静态方法调用）来调度命令。 ExecutorService就像Thread的调度程序，即Thread的池，用于处理它们的生命周期，并负责例如创建它们并启动它们。

Future是一个接口，它的一个实例可让您监视执行任务（例如Thread）的执行时间，即检查是否完成，取消它等。Callable是一个接口，实现其中的一个只是在计算/方法调用之后生成/返回结果，或者在无法生成结果的情况下抛出Exception。 Future在我们的上下文中将由ExecutorService的调度命令返回，以让我们监视提交的Callable的生命周期...

我们将要提交的Callable只会返回Scanner.nextLine方法调用的结果。通过将Callable提交给scehduler，我们得到了一个Future，它使Callable在给定的时间内等待完成。为了无限期地等待Callable的完成，我们使用了get方法。为了等待特定的超时时间（这是我们要寻找的时间），我们使用了另一个get方法，并为其提供了我们希望等待的时间。

我们可以通过ExecutorService帮助器类（可以通过实例化创建它们）在Java 8（我正在使用，您可以从链接中得知）中创建几种类型的调度程序（即Executors）。相应的类，但为简单起见，我们将使用Executors静态方法）。我不是这些方面的专家，但总的来说，有一个固定的线程池，它最多可以在任何给定的时间运行给定数量的Thread，有计划的线程池可以在以下时间执行Thread基于时间的速率和周期，它们有单线程版本（即，相同的概念，一次仅一个Thread），还有一个缓存的线程池，该线程池根据需要创建Thread并重用现有的已完成线程，最后是一个工作窃取池，它的所有线程并行地阻塞/等待工作（我不确定最后一个线程，但是根据文档，当您的任务生成其他任务等时，这很有用）。

由于我们一次提交一个Callable（一次调用一个Scanner.nextLine），因此我们可以利用单线程版本。并且由于我们不在乎定期执行提交的Callable，而是希望在每次完成后提交它，因此我们将使用固定的单线程池版本。

当用户的输入准备就绪时，您也不需要启动其他线程，但是您可以利用提交Callable的相同线程。这是以下概念代码中的主线程：

import java.util.LinkedList;
import java.util.Objects;
import java.util.Scanner;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class Concept {

    public static void main(final String[] args) {
        final LinkedList<String> q = new LinkedList<>(); //The collection to hold all user's input.
        final Scanner scan = new Scanner(System.in); //The Scanner of the System.in input stream.
        final TimeUnit waitUnit = TimeUnit.SECONDS; //What unit of time should we use when waiting for input.
        final long waitAmount = 10; //How much time (in 'waitUnit' units) should we wait for.

        //An executor with a single (daemon) thread:
        final ExecutorService scheduler = Executors.newSingleThreadExecutor(r -> {
            final Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        });

        try {
            try {
                //Main loop for reading and waiting:
                for (String input = scheduler.submit(() -> scan.nextLine()).get(waitAmount, waitUnit);
                        !Objects.equals(input, "stop");
                        input = scheduler.submit(() -> scan.nextLine()).get(waitAmount, waitUnit))
                    q.add(input); //Add the user's last input to the collection.

                //If this is reached, then the user entered "stop" as input.
                System.out.println("Ended by user's input.");
            }
            catch (final TimeoutException tx) {
                //If this is reached, then the time timed out when waiting for user's input.
                System.out.println("Ended by timeout.");
            }
            finally {
                //Here you can "consume" however you like all the user's input from the collection:
                q.forEach(line -> System.out.println(line)); //I'm just printing all of it.
            }
        }
        catch (final InterruptedException | ExecutionException x) {
            x.printStackTrace(); //This is where you handle unexpected exceptions.
        }
        finally {
            //Whatever happened, don't forget to shutdown the ExecutorService:
            scheduler.shutdown();
        }
    }
}

只需输入单词“ stop”作为输入，主线程将继续处理连接的用户输入。或者，您也可以等待10秒钟，然后将抛出 TimeoutException，再次进行连接的用户输入的处理。

我为 Executors方法调用提供了 ThreadFactory。 ThreadFactory只是一个接口，其实现为给定的 Thread创建 Runnable。 Runnable还是一个接口，这次定义了一个执行计算的单一方法（ run）。在我们的案例中，此计算是在 ExecutorService内部创建的，用于存储我们提交的 Callable结果的引用，以便可用于返回的 get的 Future方法，该方法将进而使它可用于客户的代码。我为 ThreadFactory提供的 ExecutorService正在将每个 Thread创建为一个守护程序。守护程序 Thread不会终止程序。当所有非守护程序线程都完成后，程序将终止，而与其他（守护程序）线程是否仍在运行无关。

因此，这归结为我在创建代码时遇到的问题：如果用户输入从超时停止而不是输入单词“ stop”作为输入，则意味着我们提交的 Callable尚未完成。我们提交的 Callable正在等待 System.in的输入。这样该线程将无限期运行，或者直到用户输入内容为止。如果创建的 Thread不是守护程序，则不会终止程序。这就是为什么我要使其成为守护程序。

但是，如果在超时之后，您想继续从具有（或不具有）创建的 System.in对象的 Scanner中读取内容呢？然后，您必须首先维护对最后一个 Future方法调用返回的最后一个 ExecutorService.submit的引用。

因此，这就是为什么我有另一个版本，它将扫描完全传递给另一个名为 TimedCallable的包装对象，您应该在每次扫描时使用该对象。即使超时或以“停止”字结束后，您也应继续使用它来扫描 System.in：

import java.util.LinkedList;
import java.util.Objects;
import java.util.Scanner;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class Main {

    public static class TimedCallable<V> implements Callable<V> {
        private final Callable<V> callable;
        private final ExecutorService scheduler;
        private Future<V> lastFuture;

        public TimedCallable(final Callable<V> callable) {
            this.callable = Objects.requireNonNull(callable);
            scheduler = Executors.newSingleThreadExecutor(r -> {
                final Thread t = new Thread(r);
                t.setDaemon(true); //Needs to be a daemon in order to let the program end.
                return t;
            });
            lastFuture = null;
        }

        @Override
        public synchronized V call() throws InterruptedException, ExecutionException {
            if (lastFuture == null)
                try {
                    return callable.call();
                }
                catch (final Exception x) {
                    throw new ExecutionException(x);
                }
            final V v = lastFuture.get();
            lastFuture = null;
            return v;
        }

        public synchronized V call(final TimeUnit timeoutUnit,
                                   final long timeoutAmount) throws TimeoutException, InterruptedException, ExecutionException {
            if (lastFuture == null)
                lastFuture = scheduler.submit(callable);
            final V v = lastFuture.get(timeoutAmount, timeoutUnit); /*If it throws TimeoutException,
            then the 'lastFuture' property will not be nulled by the following statement:*/
            lastFuture = null;
            return v;
        }
    }

    public static void main(final String[] args) {
        final LinkedList<String> q = new LinkedList<>(); //The collection to hold all user's input.
        final Scanner scan = new Scanner(System.in); //The Scanner of the System.in input stream.
        final TimeUnit waitUnit = TimeUnit.SECONDS; //What unit of time should we use when waiting for input.
        final long waitAmount = 10; //How much time (in 'waitUnit' units) should we wait for.

        //Instantiate the scanner's timed-callable:
        final TimedCallable<String> scanNextLine = new TimedCallable<>(() -> scan.nextLine());

        try {
            try {
                //Main loop for reading and waiting:
                for (String input = scanNextLine.call(waitUnit, waitAmount); !Objects.equals(input, "stop"); input = scanNextLine.call(waitUnit, waitAmount))
                    q.add(input); //Add the user's last input to the collection.

                //If this is reached, then the user entered "stop" as input.
                System.out.println("Ended by user's input.");
            }
            catch (final TimeoutException tx) {
                //If this is reached, then the time timed out when waiting for user's input.
                System.out.println("Ended by timeout.");
            }
            finally {
                //Here you can "consume" however you like all the user's input from the collection:
                q.forEach(line -> System.out.println(line)); //I'm just printing all of it.

                //Keep on using the Scanner via the TimedCallable:
                System.out.println("Enter next line:");
                System.out.println(scanNextLine.call());
                System.out.println("Enter last line:");
                System.out.println(scanNextLine.call());
            }
        }
        catch (final InterruptedException | ExecutionException x) {
            x.printStackTrace(); //This is where you handle unexpected exceptions.
        }
    }
}

最后的注释：我在这两个版本中均假设用户可能仍会在输入句子时因超时而中断。例如，如果您将超时设置为1秒，那么在超时到期并打乱他之前，用户可能没有足够的时间输入他想要的内容。为了更好地控制输入过程，最好创建一个GUI并注册相应的侦听器对象。