How to (reliably) interrupt threads form the main thread after a specific amount of time in Java?

Question

I just started out with threading. I wrote a main class that sets up and starts 100 threads, waits 5 seconds and then interrupts them (at least that's what I thought it did):

public static void main(String[] args) {

    List<Thread> threads = new ArrayList<Thread>();

    for (int i = 0; i < 100; i++) {
        Thread t = new Thread(new Walker());
        threads.add(t);
    }

    System.out.println("Starting threads...");

    for (Thread thread : threads) {
        thread.start();
    }

    try {
        Thread.sleep(5000);
    } catch (InterruptedException e) {
        // don't do anything
    }

    System.out.println("Time's up - Terminating threads...");
    for (Thread t : threads) {
        t.interrupt();
        System.out.print(".");
    }
    for (Thread t : threads) {
        try {
            t.join(10);
        } catch (InterruptedException e) {
            // don't do anything
        }
    }
    System.out.println("");
    System.out.println("All done.");
}

The threads looked a bit like this:

public class Walker implements Runnable {
    public void run() {
        for (int i = 0;; i++) {
            //do some complicated stuff that takes some time
            System.out.println(Thread.currentThread().getName() + ":" + i);
            if (Thread.interrupted()) {
                break;
            }
        }
    }
}

Now, the output I got was that the main thread began interrupting threads, but some sub threads continued to run a few times (i.e. loop iterations) before terminating, e.g.

Starting threads...
Thread-1:0
Thread-2:0
Thread-1:1
Thread-3:0
[...]
Time's up - Terminating threads...
......Thread-1:60
Thread-1:61
...Thread-1:62
Thread-2:55
..All done.
[output from threads sometimes continued even here - after the join()]

At that time I didn't fully understand that a single thread could be allocated enough processor time to run a few times - I expected at most one additional run before the main thread had the opportunity to interrupt it.

But while I now see that it is absolutely fine for a thread to be executed for some (long) time before the main thread gets a chance to terminate (i.e. interrupt) it, I am still wondering: is there an easy way to interrupt all child threads in a timely manner from the main thread? (Setting a "time to live" through a thread's constructor and then testing inside the Walker class for it is not what I want.)

Also: is it possible for the last print statement to execute and then see some output from individual threads - after all threads were join()ed? (Maybe I have a glitch somewhere else; the actual code is a bit more complex...)

Answer 1

The problem you observe is probably due to how System.out.println works. It is a synchronized method. So a likely explanation is:

• when calling System.out.print("."); after t.interrupt();, your main thread acquires the lock to print
• before the lock is released, worker threads arrive at System.out.println(Thread.currentThread().getName() + ":" + i); and wait for the lock
• when the main thread releases the lock, all the worker threads that were waiting print their progress.
• the main thread arrives at System.out.print("."); again and has to wait for the print lock to be available, etc.

Regarding the fact that you see more prints from the worker threads after "All Done" is printed: you only join for 10 ms, so it is possible that it is not enough and a thread is not finished within 10ms of being interrupted. If you just use join() you should not see that any longer.

Example of Worker class that reproduces the behaviour you observe:

class Walker implements Runnable {

    public void run() {
        for (int i = 0;; i++) {
            try {
                Thread.sleep(100);
            } catch (InterruptedException ex) {
                //do not respond to interruption too quickly on purpose
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {}
                Thread.currentThread().interrupt();
            }
            System.out.println(Thread.currentThread().getName() + ":" + i);
            if (Thread.interrupted()) {
                break;
            }
        }
    }
}