Show List
Tutorials > Java > Java Executor Framework Explained with Examples

Java Executor Framework Explained with Examples

The Java Executor Framework, part of the java.util.concurrent package, is a high-level concurrency API designed to simplify thread management and task execution. It abstracts low-level thread creation by providing flexible thread pools and execution policies, allowing developers to submit Runnable or Callable tasks for asynchronous processing. Key components include Executor, ExecutorService, ThreadPoolExecutor, and ScheduledExecutorService. This guide explores each concept with practical examples to help you build scalable, efficient, and well-managed multithreaded applications using Java.

Key components and concepts of the Executor framework include:

  1. Executor Interfaces:

    • Executor: The root interface of the Executor framework. It defines a single method, execute(Runnable command), which is used to submit a task for execution. Implementations of this interface are responsible for defining the execution policy, such as whether the task will be executed in a new thread, a pooled thread, or asynchronously.

    • ExecutorService: An extension of the Executor interface, it adds methods for managing the lifecycle of thread pools, such as submitting tasks, shutting down the executor, and waiting for submitted tasks to complete.

    • ScheduledExecutorService: An extension of ExecutorService, it provides methods for scheduling tasks to run at specific times or with fixed-rate or fixed-delay intervals.

  2. Executor Implementations:

    • Executors: A utility class that provides factory methods for creating various types of executors, including single-threaded executors, fixed-size thread pools, cached thread pools, and scheduled thread pools.

  3. ThreadPool Executors:

    • ThreadPoolExecutor: A customizable executor that allows fine-grained control over the number of threads, queue size, and other parameters. Developers can configure its core pool size, maximum pool size, keep-alive time, and thread factory.

    • ScheduledThreadPoolExecutor: An extension of ThreadPoolExecutor that provides support for scheduling tasks.

  4. Callable and Future:

    • Callable<V>: A functional interface similar to Runnable, but it can return a result. It is used to represent tasks that return values when executed.

    • Future<V>: Represents the result of a computation that may not be available yet. It allows you to retrieve the result of a Callable task when it's completed or to cancel the task.

  5. Thread Pools:

    • Thread pools are managed collections of worker threads used by executors to execute tasks. They help minimize thread creation and destruction overhead.

    • Common thread pool types include fixed-size, cached, and scheduled thread pools, each with its own use case and characteristics.

  6. Task Execution:

    • Tasks are represented by Runnable or Callable objects and are submitted to executors for execution. The executor framework handles the scheduling, execution, and lifecycle of threads.

  7. Completion and Exception Handling:

    • Future objects can be used to check the completion status of tasks and retrieve their results. They also support exception handling.

  8. Shutdown and Cleanup:

    • Properly shutting down an executor is essential to release resources and terminate threads. The ExecutorService interface provides methods like shutdown() and shutdownNow() to gracefully terminate the executor.

The Executor framework is an important tool for managing thread execution in Java applications. It abstracts away many of the low-level details of thread management, making it easier to write concurrent programs. By using the framework, you can efficiently manage and control the execution of tasks, minimize thread creation overhead, and improve the scalability and reliability of your multithreaded applications.

Here's a simple Java code example that demonstrates the use of the Executor framework to execute tasks concurrently using a fixed-size thread pool:

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExecutorFrameworkExample {
    public static void main(String[] args) {
        // Create a fixed-size thread pool with 3 threads
        ExecutorService executor = Executors.newFixedThreadPool(3);

        // Submit tasks for execution
        for (int i = 1; i <= 5; i++) {
            final int taskNumber = i;
            executor.execute(() -> {
                // This is the task's code to be executed
                System.out.println("Task " + taskNumber + " is running on thread " + Thread.currentThread().getName());
            });
        }

        // Shutdown the executor when done
        executor.shutdown();
    }
}

In this example:

  1. We create a fixed-size thread pool with three threads using Executors.newFixedThreadPool(3).

  2. We submit five tasks for execution in the thread pool using the execute method of the ExecutorService. Each task is represented by a lambda expression that prints a message indicating the task number and the thread it's running on.

  3. After submitting all tasks, we call executor.shutdown() to gracefully shut down the executor. This ensures that the executor and its underlying threads are terminated when all tasks are completed.

When you run this code, you'll see that the five tasks are executed concurrently by the three threads in the thread pool. The tasks are distributed among the available threads, and each task runs on a thread assigned by the executor.

The Executor framework provides a high-level and efficient way to manage and execute tasks concurrently, making it easier to work with multithreaded applications in Java.

How do I execute CompletableFuture using ExecutorService?

ChatGPT said:
ChatGPT

To execute a CompletableFuture using an ExecutorService, you can explicitly pass the ExecutorService to methods like supplyAsync or runAsync. This allows you to control the thread pool used for asynchronous tasks instead of relying on the default ForkJoinPool.

Steps to Execute CompletableFuture with ExecutorService

1. Create an ExecutorService

You can create an ExecutorService using utility classes like Executors.

2. Use supplyAsync or runAsync

  • Use supplyAsync: For tasks that return a result.
  • Use runAsync: For tasks that do not return a result.

Pass the custom ExecutorService as the second argument to these methods.

3. Shut Down the Executor

After all tasks are completed, shut down the ExecutorService to release resources.

Code Example

java
import java.util.concurrent.*;

public class CompletableFutureWithExecutorService {

    public static void main(String[] args) {
        // Step 1: Create an ExecutorService
        ExecutorService executor = Executors.newFixedThreadPool(3);

        try {
            // Step 2: Use CompletableFuture with the custom ExecutorService
            CompletableFuture<String> future = CompletableFuture.supplyAsync(() -> {
                System.out.println("Running task on thread: " + Thread.currentThread().getName());
                return "Task Completed!";
            }, executor);

            // Step 3: Handle the result
            future.thenAccept(result -> System.out.println("Result: " + result))
                  .exceptionally(ex -> {
                      System.err.println("Exception occurred: " + ex.getMessage());
                      return null;
                  });

            // Wait for all tasks to complete
            future.join();
        } finally {
            // Step 4: Shut down the ExecutorService
            executor.shutdown();
        }
    }
}

Explanation

  1. ExecutorService Creation:

    java
    ExecutorService executor = Executors.newFixedThreadPool(3);

    Creates a thread pool with 3 threads.

  2. Pass ExecutorService to supplyAsync:

    java
    CompletableFuture.supplyAsync(() -> { ... }, executor);

    This ensures that the task is executed using the threads in the custom ExecutorService.

  3. Task Execution:

    • The lambda passed to supplyAsync represents the task.
    • In this case, it prints the thread name and returns a result.

  4. Handle Result:

    java
    future.thenAccept(result -> System.out.println("Result: " + result));

    Once the computation is complete, the result is printed.

  5. Shut Down the Executor:

    java
    executor.shutdown();

    Ensures that the threads in the executor are released.

Output Example

arduino
Running task on thread: pool-1-thread-1
Result: Task Completed!

Alternative: Using runAsync

If the task does not return a result, use runAsync:

java
CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
    System.out.println("Task running on thread: " + Thread.currentThread().getName());
}, executor);
future.join();

Why Use ExecutorService with CompletableFuture?

  1. Control Over Thread Pool:

    • You can configure the number of threads, priority, and thread lifecycle.
    • Suitable for resource-intensive or I/O-bound tasks.

  2. Avoid ForkJoinPool Contention:

    • By default, CompletableFuture uses ForkJoinPool.commonPool, which may be shared by other parts of your application.
    • Using a custom ExecutorService isolates your tasks.

The Java Executor Framework provides a structured and scalable approach to handle concurrency in applications. By using thread pools, lifecycle-aware executors, and features like Callable, Future, and CompletableFuture, you can write efficient and maintainable multithreaded code. Whether you're optimizing performance or simplifying thread logic, the Executor Framework is a must-have tool in your Java developer toolkit.

FAQ Section

1. What is the Executor Framework in Java?

The Executor Framework is a high-level API in Java for managing and executing tasks using thread pools, without directly managing thread lifecycle.

2. What is the difference between Executor and ExecutorService?

Executor defines a simple execute() method, while ExecutorService adds lifecycle methods like submit(), shutdown(), and invokeAll().

3. Why should I use thread pools?

Thread pools minimize the overhead of thread creation, improve performance, and allow better control over concurrency.

4. What is the use of Callable and Future?

Callable allows tasks to return results. Future provides access to the result, blocking or non-blocking.

5. How does ScheduledExecutorService work?

It allows you to schedule tasks at fixed-rate or fixed-delay intervals using methods like scheduleAtFixedRate().

6. Can I use CompletableFuture with custom ExecutorService?

Yes, pass your ExecutorService to supplyAsync() or runAsync() to control async task execution.

7. How do I shut down an executor properly?

Call shutdown() for graceful termination and awaitTermination() if you want to wait for tasks to complete.

8. What is ThreadPoolExecutor?

It’s a flexible, low-level implementation of ExecutorService allowing custom tuning of thread behavior, queueing, and rejection policies.



Next: Java Asynchronous Processing: @Async, CompletableFuture & More

    Leave a Comment

  • captcha text