Using an Executor Service – Concurrency: Part II
Using an Executor Service
The idiom for using an executor service is embodied in the following steps that are illustrated in Example 23.1:
• Create the executor service.
• Submit tasks to the executor service.
• Shut down and terminate the executor service.
Example 23.1 Executor Lifecycle
package executors;
import java.util.concurrent.*;
public class ExecutorLifecycle {
// Task: dice roll.
private static final Runnable diceRoll = () -> { // (1)
int diceValue = ThreadLocalRandom.current().nextInt(1, 7); // [1, 6]
String threadName = Thread.currentThread().getName();
System.out.println(threadName + ” => dice value: ” + diceValue);
try {
TimeUnit.MILLISECONDS.sleep(100);
} catch (InterruptedException e) {
System.out.println(threadName + “: ” + e);
}
};
public static void main(String[] args) {
System.out.printf(“%50s %s%n”, “isShutdown()”, “isTerminated()”);
// Create the executor service:
ExecutorService es = Executors.newFixedThreadPool(3); // (2)
try { // (3)
checkStates(es, “Before execute() at (4): “);
// Submit tasks:
es.execute(diceRoll); // (4)
es.execute(diceRoll);
es.execute(diceRoll);
checkStates(es, “After execute() at (4): “);
} finally { // (5)
// Shut down the executor service:
checkStates(es, “Before shutdown() at (6a): “);
es.shutdown(); // (6a)
checkStates(es, “After shutdown() at (6a): “);
// checkStates(es, “Before shutdownNow() at (6b): “);
// es.shutdownNow(); // (6b)
// checkStates(es, “After shutdownNow() at (6b): “);
}
// Second phase of shutdown:
// awaitAndShutdownNow(es, 2, TimeUnit.SECONDS); // (7a)
// awaitAndShutdownNow(es, 1, TimeUnit.MILLISECONDS); // (7b)
}
private static void checkStates(ExecutorService es, String msg) { // (8)
System.out.printf(“%-40s %-5s %-5s%n”,
msg, es.isShutdown(), es.isTerminated());
}
private static void awaitAndShutdownNow( // (9)
ExecutorService es, int timeout, TimeUnit timeunit) {
try {
// Timed wait for tasks to complete execution:
if (!es.awaitTermination(timeout, timeunit)) { // (10)
// Attempt to cancel any uncompleted and waiting tasks:
checkStates(es, “Before shutdownNow() at (11): ” );
es.shutdownNow(); // (11)
checkStates(es, “After shutdownNow() at (11): ” );
// Timed wait for tasks to be cancelled:
while (!es.awaitTermination(timeout, timeunit)) { // (12)
System.out.println(“All tasks not yet completed at (12).”);
}
}
checkStates(es, “After awaitTermination() at (10): ” );
} catch (InterruptedException ie) { // (13)
// Attempt to cancel any uncompleted and waiting tasks:
es.shutdownNow(); // (14)
// Reinstate the interrupt status.
Thread.currentThread().interrupt();
checkStates(es, “After interruption: “);
}
}
}
Probable output from the program when calling the shutdown() method at (6a):
isShutdown() isTerminated()
Before execute() at (4): false false
After execute() at (4): false false
Before shutdown() at (6a): false false
pool-1-thread-3 => dice value: 6
pool-1-thread-1 => dice value: 2
pool-1-thread-2 => dice value: 1
After shutdown() at (6a): true false
Probable output from the program when calling the shutdownNow() method at (6b):
isShutdown() isTerminated()
Before execute() at (4): false false
After execute() at (4): false false
pool-1-thread-3 => dice value: 4
pool-1-thread-2 => dice value: 5
pool-1-thread-1 => dice value: 5
Before shutdownNow() at (6b): false false
After shutdownNow() at (6b): true false
pool-1-thread-3: java.lang.InterruptedException: sleep interrupted
pool-1-thread-1: java.lang.InterruptedException: sleep interrupted
pool-1-thread-2: java.lang.InterruptedException: sleep interrupted
Example 23.1 implements the necessary steps for using an executor service:
- Create the executor service.
The utility class Executors provides methods for creating a wide range of executor services (Table 23.2). Appropriate executor service is created based on the desired task execution policy. In Example 23.1, a fixed thread pool with three worker threads is created at (2) to execute three tasks.
ExecutorService es = Executors.newFixedThreadPool(3);
- Submit tasks to the executor service.
The task submitted to the executor service is defined as Runnable at (1). It simulates a dice roll, and when executed, it prints the dice value. The executing thread then sleeps for 100 milliseconds to prolong the execution time for the task to illustrate executor shutdown and termination.
The tasks are submitted to the executor service using the execute() method— other methods are explored later (p. 1436, p. 1440). Each call to the execute() method will result in a new task being submitted. The implementation of the Runnable diceRoll will be executed three times, each time as a separate task.
es.execute(diceRoll); // (4)
es.execute(diceRoll);
es.execute(diceRoll);
- Shut down and terminate the executor service.
