Turn messy work into tasks that have clear inputs, outputs, and ownership of data. You will practice writing tasks that can run safely without depending on hidden order.

Handle race conditions, visibility, synchronized blocks, volatile fields, and atomic classes at the level needed to use pools safely. The goal is to know when shared state is safe, when it is risky, and when to avoid it.

Trace the path from raw Thread objects to java.util.concurrent, ExecutorService, ForkJoinPool, CompletableFuture, and virtual threads. This explains why Java has several concurrency APIs and which problems each generation tried to solve.

Use ExecutorService to submit work without creating a new thread for every task. You will run tasks with execute and submit, compare common Executors factory methods, and spot unsafe defaults such as unbounded growth.

Close pools with shutdown, shutdownNow, awaitTermination, and graceful fallback plans. You will prevent lost work, hung processes, and applications that cannot exit.

Use Callable and Future when background work must return a value or report failure. You will collect results, handle checked exceptions, and avoid blocking in the wrong place.

Apply interruption, Future.cancel, timeouts, and cooperative cancellation. You will write tasks that stop cleanly instead of ignoring shutdown requests or leaving resources open.

Build a pool directly with ThreadPoolExecutor and choose core size, maximum size, keep-alive time, ThreadFactory, and rejection policy. This gives you control beyond the shortcut Executors methods.

Compare direct handoff queues, bounded queues, unbounded queues, and priority queues. You will see how the queue choice changes latency, memory use, fairness, and failure behavior under load.

Use rejection handlers to protect the system when too much work arrives. You will design backpressure with CallerRunsPolicy, fail-fast behavior, retries, and clear user-facing errors.

Estimate and measure pool sizes for CPU-bound work, blocking work, mixed workloads, and limited downstream services. You will use simple formulas, load tests, and real metrics instead of guesses.

Diagnose nested task waits, lock ordering bugs, starvation, thread leaks, and pools that depend on themselves. You will practice designs that keep progress possible even when work is slow.

Capture exceptions from execute, submit, afterExecute, UncaughtExceptionHandler, and logging frameworks. You will make failures visible and keep one bad task from silently damaging the system.

Use ScheduledExecutorService for delayed tasks, fixed-rate jobs, and fixed-delay jobs. You will handle clock drift, overlapping work, missed runs, and shutdown for scheduled pools.

Use ForkJoinPool for recursive CPU work such as splitting arrays, trees, and search problems. This chapter covers work stealing, RecursiveTask, RecursiveAction, common-pool risks, and when not to use it.

Build multi-step async flows with CompletableFuture without blocking worker threads. You will choose thenApply, thenCompose, allOf, exception handling, and custom executors for real pipelines.

Handle ThreadLocal, logging MDC, security context, locale, tracing IDs, and cleanup when tasks move between threads. You will avoid context leaks that expose one request’s data to another.

Match pools to blocking calls such as file IO, JDBC, REST clients, message brokers, and rate-limited services. You will protect database connections, HTTP clients, and external systems from being overwhelmed.

Work with pools inside servlet containers, application servers, Spring @Async, schedulers, and managed executors. You will know when to create your own pool, when to use the platform’s pool, and how to avoid fighting the runtime.

Adjust thread pool choices for containers, CPU quotas, memory limits, Kubernetes probes, autoscaling, and rolling shutdown. Modern deployment changes what “available processors” and safe capacity really mean.

Read pool health through active count, queue depth, completed tasks, latency, logs, Java Flight Recorder, JDK Mission Control, and thread dumps. You will connect symptoms to causes before changing code.

Test concurrent code with latches, barriers, fake executors, time control, stress tests, and repeatable failure cases. You will reduce flaky tests while still catching timing bugs.

Follow a realistic tuning path from user complaints to evidence, hypothesis, change, validation, and rollout. You will practice fixing slow response times, growing queues, rejected work, and blocked threads.

Use Java virtual threads for blocking-style code with far lower thread cost. This chapter covers newThreadPerTaskExecutor, carrier threads, pinning, synchronized hot spots, ThreadLocal caution, and when platform thread pools still matter.

Group related tasks so they start, fail, cancel, and finish as one unit using structured concurrency patterns and modern Java APIs. You will compare this style with ad hoc ExecutorService code and CompletableFuture chains.

Set limits, isolate tenants, protect secrets in task context, clean up resources, and design safe degradation when background work fails. You will treat thread pools as shared production infrastructure, not just code helpers.

Design, build, test, deploy, and monitor a background job service that accepts requests, queues work, runs it in a pool, records results, handles retries, and shuts down cleanly. This end-to-end project ties together sizing, cancellation, errors, observability, and operational decisions.

Map thread-pool skill to backend, platform, performance, DevOps, and library-maintainer work. You will choose proof-of-skill projects, know which Java certifications may help, and build habits for staying current with JDK changes and production concurrency practice.