Thread Pools & Executors

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

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a pool that REUSES exactly 3 threads for every task.
        // You hand it work; it decides which thread runs each piece.
        ExecutorService pool = Executors.newFixedThreadPool(3);

        // Submit 6 tasks. Only 3 run at once; the rest WAIT in a queue.
        for (int i = 1; i <= 6; i++) {
            int taskId = i;                       // capture i for the lambda
            pool.submit(() -> {                   // submit() hands the pool a Runnable
                String worker = Thread.currentThread().getName();
                System.out.println("Task " + taskId + " ran on " + worker);
            });
        }

        // shutdown() = "no new tasks", but let queued ones finish.
        pool.shutdown();
        // Block here until every task is done (or 10s passes).
        pool.awaitTermination(10, TimeUnit.SECONDS);
        System.out.println("All tasks finished. Pool closed.");
    }
}

Task 1 ran on pool-1-thread-1
Task 2 ran on pool-1-thread-2
Task 3 ran on pool-1-thread-3
Task 4 ran on pool-1-thread-1
Task 5 ran on pool-1-thread-2
Task 6 ran on pool-1-thread-3
All tasks finished. Pool closed.

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

public class Main {
    public static void main(String[] args) throws Exception {
        ExecutorService pool = Executors.newFixedThreadPool(2);

        // A Runnable returns nothing. A Callable RETURNS a value.
        Callable<Integer> job = () -> {
            int sum = 0;
            for (int i = 1; i <= 100; i++) sum += i;   // 1 + 2 + ... + 100
            return sum;                                 // hand back the answer
        };

        // submit(Callable) gives you a Future: a handle to a result
        // that may not exist YET. The main thread keeps running.
        Future<Integer> future = pool.submit(job);
        System.out.println("Submitted — main thread is free to do other work");

        // future.get() BLOCKS until the result is ready, then returns it.
        // Use the timeout version so a stuck task can't hang you forever.
        int result = future.get(5, TimeUnit.SECONDS);
        System.out.println("Sum of 1..100 = " + result);

        pool.shutdown();
        pool.awaitTermination(5, TimeUnit.SECONDS);
    }
}

Submitted — main thread is free to do other work
Sum of 1..100 = 5050

import java.util.concurrent.*;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // The factory methods are shortcuts. THIS is what they build —
        // and building it yourself lets you set a BOUNDED queue + a
        // rejection policy, the two settings that keep a server alive.
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                2,                                   // corePoolSize: threads kept alive
                4,                                   // maximumPoolSize: hard ceiling
                30L, TimeUnit.SECONDS,               // keepAlive: idle extra threads die after 30s
                new ArrayBlockingQueue<>(100),       // BOUNDED queue — refuses to grow forever
                new ThreadPoolExecutor.CallerRunsPolicy()); // overflow: caller runs it (backpressure)

        for (int i = 1; i <= 5; i++) {
            int n = i;
            pool.submit(() -> System.out.println("Job " + n + " on " + Thread.currentThread().getName()));
        }

        System.out.println("core=" + pool.getCorePoolSize() + " max=" + pool.getMaximumPoolSize());

        pool.shutdown();
        pool.awaitTermination(10, TimeUnit.SECONDS);
    }
}

Job 1 on pool-1-thread-1
Job 2 on pool-1-thread-2
Job 3 on pool-1-thread-1
Job 4 on pool-1-thread-2
Job 5 on pool-1-thread-1
core=2 max=4