6.JUC

CPU caches, coherence, out-of-order execution, memory ordering, and why language memory models exist above hardware.

Java intrinsic monitors, mutual exclusion, happens-before visibility, reentrancy, synchronized methods/blocks, and JVM implementation caveats.

Java volatile visibility and ordering semantics, acquire/release-style happens-before behavior, atomic single reads/writes, and why volatile is not a lock.

Atomic compare-and-set as a read-modify-write primitive, retry loops, contention, ABA, and when lock-free does not mean contention-free.

AQS as the state-and-wait-queue framework behind many JUC synchronizers, with exclusive/shared acquisition, parking, cancellation, and template methods.

Explicit reentrant mutual exclusion with interruptible/timed acquisition, optional fairness, Conditions, and try/finally release.

Condition variables with await/signal, predicate loops, lock association, spurious wakeups, and the relationship to Object.wait/notify.

A reusable barrier that releases a group when all parties arrive, with barrier actions, broken-barrier behavior, and comparison with CountDownLatch.

A one-shot shared countdown synchronizer for waiting until N events complete, with AQS shared-mode semantics.

How CopyOnWriteArrayList provides lock-free reads by publishing immutable array snapshots, and when its write cost makes it unsuitable.

CopyOnWriteArraySet semantics, implementation relationship with CopyOnWriteArrayList, snapshot iteration, and read-heavy use cases.

A fixed-capacity array-backed blocking queue with explicit backpressure, FIFO element order, and optional fairness.

Per-thread context storage, ThreadLocalMap lifetime, weak keys, stale values, thread-pool leaks, remove(), and modern context-propagation considerations.

Java thread-pool execution policy, core/max workers, work queues, rejection, shutdown, sizing, bounded backpressure, and modern virtual-thread context.

Composable asynchronous computation with CompletableFuture: stage chaining, error handling, executors, blocking hazards, and cancellation semantics.

Historical JDK 7 ConcurrentHashMap design: segmented locking, read concurrency, and why these internals should not be generalized to modern JDKs.

Java ForkJoinPool, recursive task decomposition, work stealing, common-pool behavior, and the limits of fork/join for blocking work.

How Java Exchanger pairs two threads at a rendezvous point and atomically swaps one value from each participant.

A reentrant read/write lock with shared readers, exclusive writers, optional fairness, lock downgrading, and workload trade-offs.

Permit-based concurrency control with acquire/release, bounded resource access, optional fairness, and the distinction from rate limiting.

User-level versus kernel-level threads, the traditional Java platform-thread mapping, and how virtual threads change the model.

Why sun.misc.Unsafe exists, what low-level operations it exposes, and why supported Java APIs should usually be preferred.

Java's memory model, data races, happens-before, synchronization order, volatile, monitors, thread start/join, final fields, and sequential consistency for correctly synchronized programs.

Durable lock-performance principles: reduce contention and critical sections, avoid blocking work while locked, split ownership carefully, and treat JVM lock internals as version-sensitive.

A teaching implementation of a synchronizer using atomic state, a FIFO wait queue, park/unpark, and release wakeups, emphasizing invariants rather than copying JDK internals.

How fair ReentrantLock reduces barging by honoring queued predecessors, and the throughput/latency trade-off of fairness.

Producer-consumer queues with bounded capacity, blocking/timed operations, backpressure, and the semantics of major Java BlockingQueue implementations.

Convenience ExecutorService factories, their hidden queue/thread choices, and why explicit executor configuration or virtual-thread executors are often clearer.

Historical JDK 8 ConcurrentHashMap design: CAS insertion, bin synchronization, tree bins, cooperative resizing, and stable public semantics.

Producer-consumer coordination with BlockingQueue, wait/notify, and Condition, including bounded capacity and correct wait-loop semantics.

Default read/write-lock acquisition, reader/writer barging policy, writer-starvation avoidance heuristics, and throughput trade-offs.

Default semaphore barging behavior, shared AQS permit state, and why nonfair acquisition often improves throughput.

Thread.sleep timing semantics and the important difference between sleeping and waiting on an object monitor.

Default ReentrantLock barging behavior, why it can improve throughput, and how AQS queues still handle contended waiters.

A linked-node blocking queue with optional capacity, separate producer/consumer coordination, and the risk of its very large default bound.

ThreadPoolExecutor overload policies as backpressure: abort, caller-runs, discard, discard-oldest, and custom rejection semantics.

A minimal Java deadlock caused by inconsistent lock ordering, plus detection and prevention techniques.

Fair read/write-lock scheduling, queued predecessors, reader grouping, writer progress, and fairness costs.

AQS shared acquisition with predecessor-aware fairness and the throughput trade-off of ordered permit allocation.

The six Thread.State values, what each means, and why Java thread state is not identical to an operating-system scheduler state.

An unbounded priority heap for concurrent producers/consumers, with ordering, capacity, and starvation caveats.

A zero-capacity rendezvous queue that directly hands an element from producer to consumer, with fair/nonfair transfer modes and thread-pool implications.

AtomicInteger/Long/Reference, CAS-based read-modify-write, accumulators/adders, atomic references, memory semantics, and contention trade-offs.