24 lessons · Java 21 core and Java 25 diagnostics

Make concurrent Java correct before making it busy.

Trace tasks across shared memory, executors, cancellation, virtual threads, finite resources, and production evidence—without confusing thread count with capacity.

Six ordered modules · approximately 8 hours

Move from correctness to production capacity.

Java 21 examples form the executable core while Java 25 diagnostic behavior stays versioned and evidence-bound.

Module 01 · 4 lessons

Shared state and correctness

Build one model for task ownership, visibility, atomicity, locking, concurrent collections, and business invariants.

Module 02 · 4 lessons

Task execution, composition, and cancellation

Own executor admission, compose asynchronous results, propagate deadlines, and distinguish cancellation requests from stopped effects.

Module 03 · 2 lessons

Virtual threads and structured tasks

Use Java 21 virtual threads deliberately, then isolate Java 25 Scoped Values and JDK 26 preview Structured Concurrency.

Module 04 · 4 lessons

Capacity and production operations

Protect finite resources through bulkheads, backpressure, admission, and evidence-driven JVM and downstream troubleshooting.

Module 05 · 9 lessons

JVM performance, GC, and runtime diagnostics

Move from user impact through GC, managed and native memory, thread, JIT, container, and capacity evidence before changing runtime policy.

Module 06 · 1 lessons

Interactive concurrency lab

Run six deterministic queue, virtual-thread, capacity, deadline, and cancellation scenarios without creating real load.

Java Concurrency Budget Lab: Queues, Virtual Threads, and Cancellation

Practice and evidence

Model capacity, then validate the real system.

The browser lab and two existing games expose deadline isolation and overload control. They remain teaching tools, not JVM benchmarks or production calculators.

Course library

Review every lesson.

Shared lessons keep one canonical article and one completion state across their approved paths.

Java Aug 18, 2026 5 min read

Java Concurrency for Backend Systems Explained

Build a practical model of tasks, threads, shared state, race conditions, thread safety, and bounded concurrency in Java backend services.

Java Aug 18, 2026 4 min read

Java Memory Model, Visibility, and Happens-Before Explained

Understand atomicity, visibility, ordering, data races, volatile fields, safe publication, and happens-before reasoning in Java backend code.

Java Aug 18, 2026 5 min read

synchronized, Locks, and Atomic Variables in Java

Compare Java monitors, ReentrantLock, CAS, atomic variables, lock scope, fairness, and compound invariants through backend examples.

Java Mar 15, 2026 4 min read

ConcurrentHashMap Explained

A practical explanation of ConcurrentHashMap in Java, including thread safety, atomic methods, iteration behavior, and common mistakes.

Java Aug 18, 2026 4 min read

ExecutorService, Thread Pools, and Work Queues in Java

Design Java executors around admission, worker, queue, rejection, shutdown, and downstream capacity instead of treating threads as free throughput.

Java Aug 18, 2026 4 min read

Java Interruption, Cancellation, and Deadlines Explained

Propagate Java interruption and request deadlines cooperatively across executors, blocking calls, cleanup, Spring boundaries, and durable effects.

Java Aug 18, 2026 4 min read

CompletableFuture Composition, Errors, and Timeouts

Compose Java CompletableFuture stages deliberately across executors, failures, timeouts, cancellation, context, and external side-effect boundaries.

System Design Aug 2, 2026 10 min read

Timeouts, Deadlines, and Cancellation Propagation Explained

Design end-to-end request budgets that distinguish hop timeouts, propagated deadlines, cooperative cancellation, and durable side effects under backend overload.

Java Aug 18, 2026 5 min read

Java Virtual Threads for Backend Services

Use Java 21 virtual threads for blocking backend tasks while keeping CPU, connection pools, downstream limits, context, and pinning explicit.

Java Aug 18, 2026 4 min read

Scoped Values and Structured Concurrency in Modern Java

Separate Java 25 Scoped Values from JDK 26 preview Structured Concurrency and reason about bounded context, task lifetime, failure, and cancellation.

System Design Aug 2, 2026 10 min read

Bulkhead Pattern and Resource Isolation Explained

Contain backend failures by isolating concurrency, threads, connection pools, and queues across priorities, tenants, operations, and dependencies.

System Design Aug 2, 2026 11 min read

Backpressure, Bounded Queues, and Flow Control Explained

Control overload with explicit demand, bounded buffering, queue age, rejection, expiry, and end-to-end flow policies across APIs, streams, and brokers.

System Design Aug 2, 2026 10 min read

Load Shedding and Adaptive Concurrency Limits Explained

Protect backend latency and useful throughput with explicit admission, deliberate load shedding, and evidence-tuned concurrency limits.

Java Aug 18, 2026 5 min read

Production Java Concurrency Troubleshooting

Diagnose Java thread starvation, unbounded queues, lock contention, virtual-thread pinning, downstream overload, and failed cancellation with evidence.

Java Aug 19, 2026 5 min read

Production JVM Performance Diagnostics Explained

Diagnose production JVM performance from user impact through CPU, garbage collection, memory, threads, containers, and durable outcomes.

Java Aug 19, 2026 5 min read

JVM Garbage Collection Logs and Pause Diagnosis Explained

Read Java 25 garbage collection logs to distinguish allocation pressure, live-set growth, concurrent work, pauses, and Full GC safely.

Java Aug 19, 2026 5 min read

G1 Garbage Collector Diagnosis and Tuning

Diagnose Java 25 G1 young, marking, mixed, evacuation, and humongous-object behavior before making minimal evidence-backed tuning changes.

Java Aug 19, 2026 5 min read

ZGC Low-Latency Garbage Collection Diagnosis and Tuning

Diagnose generational ZGC allocation headroom, concurrent work, stalls, heap sizing, and latency-throughput tradeoffs on Java 25.

Java Aug 19, 2026 4 min read

Java Heap Dumps and Memory Leak Analysis

Use Java 25 class histograms and heap dumps to test retention and memory-leak hypotheses while controlling pause, disk, and data exposure.

Java Aug 19, 2026 4 min read

JVM Native Memory, Metaspace, and Container OOM Diagnosis

Separate Java heap, HotSpot native memory, metaspace, buffers, stacks, RSS, and container OOM evidence with Java 25 NMT.

Java Aug 19, 2026 4 min read

JVM Thread Dumps, Safepoints, and CPU Saturation Diagnosis

Diagnose Java 25 platform and virtual threads, locks, safepoints, CPU saturation, pinning, and dependency waits with bounded evidence.

Java Aug 19, 2026 5 min read

JVM JIT, Code Cache, and Warmup Diagnosis

Diagnose Java 25 tiered compilation, compilation queues, deoptimization, code cache pressure, warmup, JFR, and AOT profile boundaries.

Java Aug 19, 2026 5 min read

Evidence-Based JVM Tuning and Capacity Verification

Turn JVM performance hypotheses into controlled canary changes with representative load, rollback, resource budgets, and user-outcome verification.

Java Aug 18, 2026 6 min read

Java Concurrency Budget Lab: Queues, Virtual Threads, and Cancellation

Run six deterministic Java concurrency scenarios to compare fixed pools, virtual threads, resource guards, deadlines, and cooperative cancellation.

FAQ

Java Concurrency course questions

Which Java version does this course use?

Executable core examples target Java 21. Scoped Values are labeled as Java 25 final API, while Structured Concurrency is isolated as JDK 26 sixth preview with required preview flags.

Do virtual threads remove the need for capacity limits?

No. Virtual threads reduce the cost of waiting threads but do not add CPU, connections, memory, lock throughput, or downstream capacity. Guard scarce resources separately.

Is the concurrency lab a benchmark or thread-pool calculator?

No. It is a deterministic discrete-event teaching model and does not create threads, measure a JVM, plan capacity, or generate production configuration.

How does shared lesson progress work?

Every article keeps one canonical URL and one local completion record. Shared Virtual Threads and troubleshooting lessons count in Java Concurrency, Spring Backend, and System Design where applicable.