forum

Home / DeveloperSection / Forums / How does the ExecutorService work in Java?

Ask Question
Revati S Misra

Revati S Misra

Follow
Skilled in SEO, content writing, and digital marketing. Completed several years of working in many organizations including multinational companies. I love to learn new things in life that keep me motivated.

Can you answer this question?

Answer

1 Answers

Ashutosh Kumar Verma

Ashutosh Kumar Verma

19-Jul-2024

Working of ExecutorService 

The ExecutorService in Java provides a framework for executing and executing asynchronous tasks simultaneously. It is part of the java.util.concurrent package and is commonly used to manage a set of threads to perform tasks. Here is how the ExecutorService works:

 

Creating an ExecutorService

To create an ExecutorService, you normally use one of the factory methods provided by the Executors class. 

The most common types are,

Single Thread Executor

ExecutorService executorService = Executors.newSingleThreadExecutor();

Fixed Thread Pool

ExecutorService executorService = Executors.newFixedThreadPool(nThreads);

Cached Thread Pool

ExecutorService executorService = Executors.newCachedThreadPool();

Scheduled Executor Service

ScheduledExecutorService executorService = Executors.newScheduledThreadPool(nThreads);

 

Submitting Tasks for Execution

Once you have an ExecutorService, you submit tasks to it for execution using one of the submit() methods. Tasks can be Runnable or Callable instances.

Runnable Task

executorService.submit(new RunnableTask());

 

Callable Task

Future<Integer> future = executorService.submit(new CallableTask());

 

 

Execution and Task Handling

When the job is passed to ExecutorService,

 

  • If it is Runnable, the task is executed asynchronously by a thread from the ExecutorService's pool.
  • If it is Callable, the operation is performed in the same way, but it can return a result created in the Future.

 

 

Managing Task Completion

The submit() method returns a Future object, which allows you to track the status and retrieve the results of the operation.

Future Object

Future<Integer> future = executorService.submit(new CallableTask());
try {
   Integer result = future.get();  // Blocking call to get the result
   System.out.println("Result: " + result);
} catch (InterruptedException | ExecutionException e) {
   e.printStackTrace();
}

 

 

Shutting Down the ExecutorService

Once the ExecutorService is finished, you must close it to release its resources and stop its thread from running:

Shutdown

executorService.shutdown();

Graceful Shutdown

executorService.shutdown();
try {
   if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
       executorService.shutdownNow();
       if (!executorService.awaitTermination(60, TimeUnit.SECONDS)) {
           System.err.println("ExecutorService did not terminate");
       }
   }
} catch (InterruptedException e) {
   executorService.shutdownNow();
   Thread.currentThread().interrupt();
}

 

ExecutorService provides a simple and efficient way to handle concurrent tasks in Java applications. It removes the complexity of manual threads and provides features such as job submission, execution, result retrieval, and elegant closure. Using ExecutorService, developers can use thread pooling and concurrency to ensure optimal resource utilization and improve the performance and responsiveness of their applications

 

Also, Read: What are default and static methods in interfaces in java?

Liked By