Using an Executor Service 2 – Concurrency: Part II
When the executor service is no longer needed, it should be closed properly so that resources associated with the executor service can be reclaimed. As an executor service is not AutoCloseable, we cannot use the try-with-resources statement. The simplest shutdown procedure involves either calling the shutdown() or shutdownNow() method for this purpose. Calling either of these methods shuts down the executor service, after which any attempts to submit new tasks to the executor service will be rejected. However, the shutdown() method will allow actively executing tasks and any waiting tasks to complete, but the shutdown-Now() method will attempt to cancel actively executing tasks and halt the processing of any waiting tasks.
The shutdown procedure is typically performed in a finally block associated with a try block containing the code that uses the executor service. This setup ensures that the executor service will always be shut down no matter how the tasks execute.
The method checkStates() at (9) in Example 23.1 is used to determine whether the executor service has been shut down and/or terminated at various stages in the execution, as can be seen in the program output.
The code below from Example 23.1 sketches the steps involved in using an executor:
// Create the executor service:
ExecutorService es = Executors.newFixedThreadPool(3);
try { // (3)
// Submit tasks:
es.execute(diceRoll); // (4)
es.execute(diceRoll);
es.execute(diceRoll);
} finally { // (5)
// Shut down the executor service:
es.shutdown(); // (6a)
//es.shutdownNow(); // (6b)
}
Two scenarios are shown in the output from the program in Example 23.1, corresponding to using the shutdown() and the shutdownNow() methods at (6a) and (6b), respectively. These methods do not wait for previously submitted tasks to complete execution before returning. Note that the isTerminated() method returns false after shutdown as one or more threads might not have completed execution—in this particular case, most probably waiting for sleep to time out. It is also important to note that the JVM will not terminate until all active threads in the thread pool have completed execution—analogous to normal threads in an application.
In the output, we see that the default name of a worker thread is composed of a thread pool number and a thread number—for example, pool-1-thread-3.
The output from the program when calling the shutdown() method at (6a) shows that the executor service did shut down, but the executor service did not terminate as some tasks continued execution—the method isTerminated() returned false when called after return from the shutdown() method. However, any running or submitted tasks were allowed to complete execution before the JVM terminated—in this particular case, threads were allowed to sleep until timed out.
In contrast, calling the shutdownNow() method cancels any executing and pending tasks. The shutdownNow() method does not wait for pending tasks to terminate.
From the output, we can see that calling the isTerminated() method on the executor returns false, as the executor has not terminated because all pending tasks have not been cancelled yet. The output from the program shows that, when cancelled, all three threads were interrupted while asleep. The Interrupted-Exception being caught and handled when the threads woke up and continued execution resulted in the tasks completing execution and the JVM being able to terminate.
