All 15 Concurrency & Threads questions
More in Concurrency & Threads
What are the two primary ways to create a thread in Java (extending Thread versus implementing Runnable), and which is generally preferred? What is the difference between calling Thread.start() and Thread.run() directly, and why is calling run() directly a common beginner mistake? What is the synchronized keyword, and how does it use Java's intrinsic (monitor) locks to prevent race conditions on shared mutable state? What causes a deadlock in multithreaded Java code, and what is the classic "lock ordering" strategy for preventing it? What are the atomic classes in java.util.concurrent.atomic (AtomicInteger, AtomicLong, AtomicReference), and how do they achieve thread-safe operations without traditional locking? What is thread starvation, and how can thread priority misuse or unfair lock scheduling contribute to it? What is the difference between wait()/notify()/notifyAll() (Object's intrinsic monitor methods) and the newer java.util.concurrent tools, and why are the older methods considered error-prone? What is a race condition, and how does it differ conceptually from a deadlock as two distinct categories of concurrency bugs? How does java.util.concurrent's ReentrantLock differ from the synchronized keyword, and what additional capabilities does it provide (tryLock, fairness, interruptible locking)? How do CompletableFuture's composition methods (thenApply, thenCompose, thenCombine) enable building asynchronous pipelines, and what's the difference between thenApply and thenCompose?
Advertisement
Java › Concurrency & Threads

What is the ExecutorService framework, and why is it generally preferred over manually creating and managing individual Thread objects?

Intermediate

Answer

ExecutorService decouples task submission from the mechanics of thread creation, pooling, and lifecycle management -- a fixed or cached thread pool (created via Executors factory methods, or more explicitly via ThreadPoolExecutor for fine control) reuses a bounded set of worker threads across many submitted tasks, avoiding the overhead of creating a brand-new OS thread per task, providing built-in mechanisms for graceful shutdown, task result retrieval via Future, and protecting against unbounded thread creation that could otherwise exhaust system resources under heavy load.
ExecutorService executor = Executors.newFixedThreadPool(4);

Future<Integer> future = executor.submit(() -> {
    // some computation
    return 42;
});

try {
    Integer result = future.get(5, TimeUnit.SECONDS);  // blocks with a timeout
} catch (TimeoutException e) {
    future.cancel(true);
}

executor.shutdown();  // initiates graceful shutdown, letting in-flight tasks complete
Real-world example A web service handling incoming requests submits each request's processing work to a fixed-size ExecutorService thread pool rather than spawning a new Thread per request, bounding the maximum concurrent OS thread count and preventing resource exhaustion under a traffic spike that an unbounded thread-per-request model would risk.

Common follow-ups: What's the difference between Executors.newFixedThreadPool() and newCachedThreadPool(), and when is each appropriate?;Why do many teams recommend against using the Executors factory methods directly in production, preferring explicit ThreadPoolExecutor configuration?

Background Tasks & Hosted Services;Diagnostics & Performance
All 15 Concurrency & Threads questions