How do I break a loop in one Thread from another Thread?

Question

I am new to Java and I am trying to use one Thread to finish a loop in another Thread regardless of the state of the loop.

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

What I am trying to do is end the loop in main after 10 seconds, regardless of the state of its loop because the loop contains a Scanner reading from System.in, and it needs to stop after 10 seconds regardless of what has been read from the keyboard or not. I thought the best solution would be to have a timer Thread running which counts the seconds, and then notify the loop in the other Thread somehow, after 10 seconds, to break, however, I do not know how to implement this...

Answer 1

If your goal is to stop looping after 10 seconds, there's no reason to use another thread. Just check the time locally:

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

How about something like this:

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

The safest approach to your problem is to use a volatile variable:

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 4

Don't reinvent the wheel. Use an ExecutorService and a get() with a timeout:

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 5

There are many solutions to this. Here is one of them:

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();
        }
    }
}

Explanation

In this solution, we use interrupts to make the while-loop in thread break. An interrupt stops normal thread operation at whatever point it is executing, but only if the thread calls a method that throws InterruptedException, and the thread returns (or breaks) in the catch block. Thread.interrupt() sets the interrupt status to interrupted, but does not actually interrupt the Thread from execution. The run method of thread is invoked again after being interrupted. Since we check Thread.interrupted() at the beginning of our loop, the loop will break when the loop is entered, and run exits and the Thread ceases to run. With Thread.interrupted(), you have to check, in the same Thread, for its interrupted status, and then choose what to do if the status is cleared or not.

As a side note, if our only branch (if-statement) in the loop checks for the interrupted state of that thread, then it might be easier to read and be more efficient if we simply declare our while-loop as while(!Thread.interrupted()). Otherwise it should be left as it is.

Other Solutions

Other solutions are illustrated by some other answers here, though some answer your whole problem in a different way. Some other solutions include using an AtomicBoolean as answered by Oliver Dain; another using a global lock object and volatile booleans or AtomicBoolean.

There are many solutions, but the interrupt solution seems to be the easiest and most convenient in most use-cases.