ExecutorService

Multithreading is a core part of modern Java. ExecutorService is a high-level API that lets you run tasks concurrently, manage threads efficiently, and simplify multithreaded programming. Using ExecutorService makes your programs faster, cleaner, and more scalable without manually handling threads.

---

What is ExecutorService?

ExecutorService is a Java API from the java.util.concurrent package that manages threads and executes tasks for you.

Instead of manually creating Thread objects, ExecutorService handles:

• Thread creation – Automatically creates threads for tasks.
• Thread reuse – Reuses threads from a pool to save resources.
• Task scheduling – Runs tasks immediately, after a delay, or periodically.
• Shutdown management – Safely terminates threads when done.

In simple words:

ExecutorService = Thread Manager + Task Runner

It makes multithreaded programming simpler, safer, and more efficient, especially when running many tasks concurrently.

Example:

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

publicclassExecutorServiceExample {
publicstaticvoidmain(String[] args) {
ExecutorServiceexecutor= Executors.newFixedThreadPool(2);// Thread pool with 2 threads

// Submit a task
        executor.submit(() -> System.out.println("Task is running in " + Thread.currentThread().getName()));

// Shutdown executor
        executor.shutdown();
    }
}

Output:

Task is running in pool-1-thread-1

---

Why Use ExecutorService?

ExecutorService is widely used because it simplifies multithreading and makes your programs faster and more efficient.

Here are the main benefits:

• Better Thread Management: Threads are reused from a thread pool, so you don’t have to create a new thread for every task. This reduces overhead and improves resource utilization.
• Improved Performance: Using a thread pool avoids the cost of repeatedly creating and destroying threads, which makes your application run faster.
• Easy to Use: You can submit tasks directly without writing complex low-level thread code using Runnable or Callable.
• Flexible: Works seamlessly with Runnable tasks (no return value) and Callable tasks (returns a value), giving you control over asynchronous computations.

---

Key Methods of ExecutorService

1. submit(Runnable task)

Runs a task asynchronously using a thread from the pool. Use this when you don’t need a result from the task.

Example:

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

publicclassSubmitRunnableExample {
publicstaticvoidmain(String[] args) {
ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

// Submit Runnable tasks
for (inti=1; i <=3; i++) {
inttaskId= i;
            executor.submit(() -> {
                System.out.println("Running task " + taskId +" by " + Thread.currentThread().getName());
            });
        }

        executor.shutdown();
    }
}

Sample Output:

Running task1 by pool-1-thread-1
Running task2 by pool-1-thread-2
Running task3 by pool-1-thread-1

—> Notice how threads are reused from the pool.

---

2. shutdown()

Stops accepting new tasks but finishes all already submitted tasks before shutting down.

Example:

ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

executor.submit(() -> System.out.println("Task running..."));

// Stop accepting new tasks
executor.shutdown();

System.out.println("Executor shutdown called");

Sample Output:

Task running...
Executor shutdown called

—> The executor finishes submitted tasks but will not accept new ones.

---

3. shutdownNow()

Attempts to stop all running tasks immediately. Tasks that are already running may not stop instantly.

Example:

ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

executor.submit(() -> {
try {
        Thread.sleep(2000);
        System.out.println("Long running task finished");
    }catch (InterruptedException e) {
        System.out.println("Task interrupted!");
    }
});

// Attempt to stop tasks immediately
executor.shutdownNow();
System.out.println("ShutdownNow called");

Sample Output (may vary):

Task interrupted!
ShutdownNow called

—> shutdownNow() tries to stop all tasks immediately but cannot guarantee that already running threads stop instantly.

---

4. invokeAll(Collection<Runnable/Callable> tasks)

Runs multiple tasks at the same time and waits for all of them to finish. Useful for batch processing tasks.

Example (Runnable version):

import java.util.concurrent.*;
import java.util.Arrays;
import java.util.List;

publicclassInvokeAllExample {
publicstaticvoidmain(String[] args)throws InterruptedException {
ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

        List<Runnable> tasks = Arrays.asList(
            () -> System.out.println("Task 1 done by " + Thread.currentThread().getName()),
            () -> System.out.println("Task 2 done by " + Thread.currentThread().getName())
        );

// Convert Runnable to Callable<Void> for invokeAll
        List<Callable<Void>> callables = tasks.stream()
            .map(task -> Executors.callable(task))
            .toList();

        executor.invokeAll(callables);

        executor.shutdown();
    }
}

Sample Output:

Task1 done by pool-1-thread-1
Task2 done by pool-1-thread-2

—> invokeAll() waits until all tasks are completed.

---

5. isShutdown()

Checks if the executor has been shut down (i.e., no new tasks are accepted).

Example:

ExecutorServiceexecutor= Executors.newFixedThreadPool(2);
executor.shutdown();

System.out.println("Is executor shutdown? " + executor.isShutdown());

Output:

Is executor shutdown?true

---

6. isTerminated()

Checks if all tasks have completed after shutdown.

Example:

ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

executor.submit(() -> System.out.println("Task running..."));
executor.shutdown();

while (!executor.isTerminated()) {
// Wait until all tasks finish
}

System.out.println("All tasks completed: " + executor.isTerminated());

Sample Output:

Task running...
All tasks completed:true

—> Useful to confirm all tasks are done before proceeding.

---

Example: Using ExecutorService Methods

import java.util.concurrent.*;
import java.util.Arrays;
import java.util.List;

publicclassExecutorServiceMethodsExample {
publicstaticvoidmain(String[] args)throws Exception {
// Create a fixed thread pool with 2 threads
ExecutorServiceexecutor= Executors.newFixedThreadPool(2);

// 1. Using submit(Runnable)
        executor.submit(() -> System.out.println("Runnable Task running by " + Thread.currentThread().getName()));

// 2. Using submit(Callable)
        Callable<Integer> callableTask = () -> {
intsum=0;
for (inti=1; i <=5; i++) sum += i;
return sum;
        };
        Future<Integer> futureResult = executor.submit(callableTask);
        System.out.println("Callable Task Result: " + futureResult.get());

// 3. Using invokeAll()
        Callable<String> task1 = () ->"Task1 Done";
        Callable<String> task2 = () ->"Task2 Done";
        List<Future<String>> results = executor.invokeAll(Arrays.asList(task1, task2));
for (Future<String> r : results) {
            System.out.println(r.get());
        }

// 4. Check if executor is shutdown
        System.out.println("Is executor shutdown? " + executor.isShutdown());

// 5. Shutdown executor
        executor.shutdown();
        System.out.println("Executor shutdown called");

// 6. Check if all tasks are terminated
        System.out.println("Is executor terminated? " + executor.isTerminated());
    }
}

Sample Output:

RunnableTask running by pool-1-thread-1
CallableTask Result:15
Task1 Done
Task2 Done
Is executor shutdown?false
Executor shutdown called
Is executor terminated?true

—> This example shows how different ExecutorService methods work, including submitting tasks, returning results, running multiple tasks, and shutting down the executor safely.

---

Types of ExecutorService

Java provides several types of ExecutorService depending on how you want to manage threads and tasks:

1. Fixed Thread Pool

• Creates a pool with a fixed number of threads. Threads are reused for multiple tasks.
• Syntax: Executors.newFixedThreadPool(n)
• Use Case: Best when you know the number of threads you need.

Example:

ExecutorServiceexecutor= Executors.newFixedThreadPool(3);
for (inti=1; i <=5; i++) {
inttaskId= i;
    executor.submit(() -> System.out.println("Task " + taskId +" running by " + Thread.currentThread().getName()));
}
executor.shutdown();

---

2. Cached Thread Pool

• Creates new threads as needed, and reuses idle threads.
• Syntax: Executors.newCachedThreadPool()
• Use Case: Good for applications with many short-lived tasks.

Example:

ExecutorServiceexecutor= Executors.newCachedThreadPool();
for (inti=1; i <=5; i++) {
inttaskId= i;
    executor.submit(() -> System.out.println("Task " + taskId +" running by " + Thread.currentThread().getName()));
}
executor.shutdown();

---

3. Single Thread Executor

• Runs tasks one by one in a single thread. Tasks are executed sequentially.
• Syntax: Executors.newSingleThreadExecutor()
• Use Case: Useful when tasks must run in order.

Example:

ExecutorServiceexecutor= Executors.newSingleThreadExecutor();
for (inti=1; i <=3; i++) {
inttaskId= i;
    executor.submit(() -> System.out.println("Task " + taskId +" running by " + Thread.currentThread().getName()));
}
executor.shutdown();

---

4. Scheduled Executor

• Runs tasks after a delay or periodically.
• Syntax: Executors.newScheduledThreadPool(n)
• Use Case: Ideal for timed tasks like repeated monitoring or scheduled jobs.

Example:

ScheduledExecutorServiceexecutor= Executors.newScheduledThreadPool(2);
executor.schedule(() -> System.out.println("Task executed after 2 seconds"),2, TimeUnit.SECONDS);
executor.shutdown();

---

Conclusion

ExecutorService is a powerful tool to manage threads efficiently and simplify multithreaded programming in Java.

• Reuses threads to improve performance
• Runs tasks asynchronously
• Handles multiple tasks safely
• Allows scheduled or repeated execution

By mastering ExecutorService, you can write fast, maintainable, and modern Java applications without manually managing threads.