如何从另一个线程中断一个线程中的循环？

Question

我是 Java 新手，我正在尝试使用一个线程来完成另一个线程中的循环，而不管循环的状态如何。

public static void main(String[] args) {
    // Either start the other thread here
        while(true){
            // Or here, not quite sure
            // Do stuff
        }
    }
}



public class Timer implements Runnable{

    @Override
    public void run() {
        long start = System.currentTimeMillis();
        while(true) {
            long current = System.currentTimeMillis();
            if(current - start == 10000){
                // How do I notify the loop in main to break?
                break;
            }
        }
    }
}

我要做的是在 10 秒后在 main 中结束循环，无论其循环的状态如何，因为循环包含从System.in 读取的Scanner，并且它需要在 10 秒后停止，无论从键盘读取的内容与否。我认为最好的解决方案是运行一个计时器线程来计算秒数，然后在 10 秒后以某种方式通知另一个线程中的循环中断，但是，我不知道如何实现这个......

Answer 1

如果您的目标是在 10 秒后停止循环，则没有理由使用另一个线程。只需查看当地时间：

public class Main {
    public static void main(String[] args) {
        // Instructions

        long start = System.currentTimeMillis();
        do {
            //Instructions
            //Instructions
            //...
            //Instructions   
        } while (System.currentTimeMillis() - start < 10000);
    }
}

Answer 2

这样的事情怎么样：

public static void main(String[] args) {
    // Instructions
    AtomicBoolean shouldStop = new AtomicBoolean(false);

   Timer timer = new Timer(shouldStop);
   // start the timer thread
        while(true){
            if (shouldStop.get()) {
               break;
            }

            //Instructions
        }
    }
}



public class Timer implements Runnable{
   private final AtomicBoolean shouldStop;

   public Timer(AtomicBoolean shouldStop) {
        this.shouldStop = shouldStop;
   }

    @Override
    public void run() {
        long start = System.currentTimeMillis();
        while(true){
            long current = System.currentTimeMillis();
            if(current - start == 10000) {
                shouldStop.set(true);
                break;
            }
        }
    }
}

Answer 3

不要重新发明轮子。使用 ExecutorService 和 get() 超时：

ExecutorService executor = Executors.newSingleThreadExecutor();

// Here's a lambda, but you could use an instance of a normal Runnable class
Runnable runnable = () -> {
    while(true){
        // Do stuff
    }
};

Future<?> future = executor.submit(runnable);

try {
    future.get(10, TimeUnit.SECONDS);
} catch (TimeoutException e) {
    // the task timed out
    future.cancel(true); // this will kill the running thread
} catch (InterruptedException | ExecutionException e) {
    // the runnable exploded
}

Answer 4

解决问题最安全的方法是使用 volatile 变量：

public class Main {

    private static volatile boolean keepRunning = false;

    public static void main(String[] args) {
        keepRunning = true;

        while(keepRunning) {
            //Instructions
            //...
            //Instructions   
        }
    }
}

public class Timer implements Runnable {

    @Override
    public void run() {
        long start = System.currentTimeMillis();
        while(true){
            long current = System.currentTimeMillis();
            if(current - start == 10000){
                // Notify the loop in Main to break
                keepRunning = false;
                break;
            }
        }
    }

}

Answer 5

对此有很多解决方案。这是其中之一：

public class Main {

    public static void main(String... args) {
        Thread thread = () -> {
            while(true) {
                // We call Thread.interrupted to check the interrupted status of the Thread.
                // This method also clears the interrupted status of the Thread.
                if(Thread.interrupted()) {
                    break;
                }
                // code...
            }
        }

        Thread timer = () -> {
            long start = System.currentTimeMillis();
            while(true) {
                long current = System.currentTimeMillis();
                if(current - start == 10_000){ // underscore for clarity
                    // This causes the thread to interrupt. The next pass
                    // in our loop in "thread" will first check its interrupted status
                    // before continuing, and will break if the status is interrupted
                    thread.interrupt();
                    break;
                }
            }
        }

        // wrap in synchronized block to ensure both threads run simultaneously
        synchronized(Main.class) {
            thread.start();
            timer.start();
        }
    }
}

说明

在这个解决方案中，我们使用 interrupts 使 thread 中的 while 循环中断。中断会在它正在执行的任何点停止正常的线程操作，但前提是线程调用了抛出InterruptedException 的方法，并且线程在catch 块中返回（或中断）。 Thread.interrupt() 将interrupt status 设置为中断，但实际上并不中断线程的执行。 thread的run方法被中断后再次调用。由于我们在循环开始时检查了Thread.interrupted()，因此当进入循环时循环将中断，run 退出并且线程停止运行。使用Thread.interrupted()，您必须在同一个线程中检查其中断状态，然后选择是否清除状态。

附带说明，如果我们在循环中的唯一分支（if 语句）检查该线程的中断状态，那么如果我们简单地将 while 循环声明为 @，它可能更易于阅读且效率更高987654333@。否则应该保持原样。

其他解决方案

这里的一些其他答案说明了其他解决方案，尽管有些解决方案以不同的方式回答了您的整个问题。其他一些解决方案包括使用 Oliver Dain 回答的 AtomicBoolean；另一个使用全局 lock object 和 volatile 布尔值或 AtomicBoolean。

有很多解决方案，但在大多数用例中，中断解决方案似乎是最简单和最方便的。