Question

I posted a question about a thread pattern today, and almost everyone suggested that I look into the ExecutorService.

While I was looking into the ExecutorService, I think I am missing something. What happens if the service has a running or blocked threads, and someone calls ExecutorService.shutdown(). What happens to threads that are running or blocked?

Does the ExecutorService wait for those threads to complete before it terminates?

The reason I ask this is because a long time ago when I used to dabble in Java, they deprecated Thread.stop(), and I remember the right way of stopping a thread was to use sempahores and extend Thread when necessary:

public void run () {
    while (!this.exit) {
        try {
            block();
            //do something
        } catch (InterruptedException ie) {
        }
    }
}

public void stop () {
    this.exit = true;

    if (this.thread != null) {
        this.thread.interrupt();
        this.thread = null;
    }
}

How does ExecutorService handle running threads?

Answer 1

From ExecutorService#shutdown():

Initiates an orderly shutdown in which previously submitted tasks are executed, but no new tasks will be accepted. Invocation has no additional effect if already shut down.

So it will wait for those threads to complete.

An alternative is the ExecutorService#shutdownNow()

Attempts to stop all actively executing tasks, halts the processing of waiting tasks, and returns a list of the tasks that were awaiting execution.

There are no guarantees beyond best-effort attempts to stop processing actively executing tasks. For example, typical implementations will cancel via Thread.interrupt(), so any task that fails to respond to interrupts may never terminate.

You only need to listen on Thread#isInterrupted() in the while loop inside the run() yourself.