How do Executors work in Java?

Executor is an interface in Java that defines a contract for executing tasks in a thread pool. Instead of explicitly creating threads for each task, you pass tasks to executors, which manage the creation, utilization, and destruction of threads.

Main advantages:

• Thread management: Provides a unified way to manage a thread pool, eliminating manual thread creation and synchronization.
• Efficiency: Reuses existing threads, reducing overhead associated with thread creation and destruction.
• Performance: Improves application performance and responsiveness through asynchronous task execution.

The Executor has one method:

// Executes the given command at some time in the future.
void execute(Runnable command);

Common subtypes include:

• ExecutorService: Extends Executor and provides additional methods for managing the executor's lifecycle and obtaining task results (e.g., via Future).
• ScheduledExecutorService: Extends ExecutorService and allows scheduling tasks with delays or at fixed rates.

The Executors class provides factory methods for creating various types of executors:

// Creates a thread pool with a fixed number of threads.
ExecutorService fixedThreadPool = Executors.newFixedThreadPool(5);

// Creates a thread pool that can dynamically adjust the number of threads.
ExecutorService cachedThreadPool = Executors.newCachedThreadPool();

// Creates a thread pool that can schedule tasks.
ScheduledExecutorService scheduledThreadPool = Executors.newScheduledThreadPool(3);

Example usage:

// Executor object
ExecutorService executor = Executors.newFixedThreadPool(2);

// Task to execute
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Task code
        System.out.println("Task is running in thread: " + Thread.currentThread().getName());
    }
};

// Passing the task to the executor
executor.execute(task);

// Shutting down the executor (necessary to free resources)
executor.shutdown();

When calling execute(), the executor takes the task (Runnable) and assigns it to one of the threads in its pool for execution. The executor manages task distribution among threads and their lifecycle.