About Executor Framework

Executor Framework

Java Concurrency API defines below three executor interfaces that covers everything that is needed for creating and managing threads: -

Executors Framework - This is a framework for creating and managing threads. 

Executor - A simple interface for executing tasks or A simple interface that contains a method called execute () to launch a task specified by a Runnable object.

ExecutorService -  A more complex interface which contains additional methods for managing the tasks and the executor itself or A sub-interface of Executor that adds functionality to manage the lifecycle of the tasks. It also provides a submit () method whose overloaded versions can accept a Runnable as well as a Callable object. Callable objects are similar to Runnable except that the task specified by a Callable object can also return a value.

ScheduledExecutorService - Extends ExecutorService with methods for scheduling the execution of a task or A sub-interface of ExecutorService. It adds functionality to schedule the execution of the tasks.

Executors framework helps to do following:

To Create a Group of Threads: We can create threads using the available various methods, more specifically a pool of threads, that your application can use to run the appropriate tasks concurrently.

Thread Management: It manages the life cycle of the threads in the thread pool. You don’t need to worry about whether the threads in the thread pool are active or busy or dead before submitting a task for execution.

Task submission and execution: Executors framework provides methods for submitting tasks for execution in the thread pool, and also gives us the provision to decide when the tasks will be executed. For example, you can submit a task to be executed now or schedule them to be executed later or make them execute periodically.

Q:How to Create an Executor?

If you want to create an Executor, it is possible to use Executors class factory methods. Below are the most common methods, which are used to create Executors:

An ExecutorService with a single thread to execute commands with method newSingleThreadExecutor.

A ScheduledExecutorService with a single thread to execute commands with the method newSingleThreadScheduledExecutor.

An ExecutorService that use a fixed length pool of threads to execute commands with the method newFixedThreadPool.

An ExecutorService with a pool of threads that creates a new thread if no thread is available and reuse an existing thread if they are available with newCachedThreadPool.

        A ScheduledExecutorService with a fixed length pool of threads to execute scheduled commands with the method newScheduledThreadPool.

Here are examples to creates ExecutorService and ScheduledExecutorService instances:

// Creates a single thread ExecutorService

1) ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();

// Creates a single thread ScheduledExecutorService

2) ScheduledExecutorService singleScheduledExecutorService = Executors.newSingleThreadScheduledExecutor();

// Creates an ExecutorService that use a pool of 5 threads

3) ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);

// Creates an ExecutorService that use a pool that creates threads on demand and that kill them after 60 seconds if they are not used

4) ExecutorService onDemandExecutorService = Executors.newCachedThreadPool();

// Creates a ScheduledExecutorService that use a pool of 5 threads

5) ScheduledExecutorService fixedScheduledExecutorService = Executors.newScheduledThreadPool(5);