Advanced Concurrency & Reactive Programming Course

Lesson 1 • Race Conditions and Atomicity

Identifies race conditions through check-then-act and read-modify-write patterns. Introduces atomicity as the core correctness requirement.

Lesson 2 • Processes, Threads, and Execution Units

Defines processes, threads, and lightweight fibres as distinct execution units. Establishes vocabulary used throughout the course.

Lesson 3 • Shared State and Memory Visibility

Explains how threads share heap memory and why CPU caches cause stale reads. Connects visibility problems to real data corruption bugs.

Lesson 4 • Concurrency Correctness Criteria

Defines linearizability, sequential consistency, and serializability as formal correctness models. Grounds later lock and lock-free design decisions.

Lesson 1 • Lock Granularity and Contention

Analyses coarse versus fine-grained locking trade-offs using throughput and latency metrics. Introduces lock striping as a scalable contention-reduction technique.

Lesson 2 • Read-Write Locks and Condition Variables

Introduces shared-read/exclusive-write locks for read-heavy workloads. Pairs condition variables with mutexes for wait-notify coordination.

Lesson 3 • Semaphores and Barriers

Uses counting semaphores to bound resource pools and cyclic barriers to synchronise phases. Maps each primitive to its canonical use case.

Lesson 4 • Avoiding Common Locking Pitfalls

Catalogues lock inversion, nested lock acquisition, and lock leaks as recurring defects. Provides refactoring patterns to eliminate each pitfall.

Lesson 1 • Immutability as a Concurrency Strategy

Demonstrates how immutable objects eliminate synchronisation entirely. Covers effective immutability, defensive copying, and persistent data structures.

Lesson 2 • Concurrent Queues and Deques

Covers blocking and non-blocking queue implementations for producer-consumer pipelines. Compares bounded versus unbounded queue back-pressure behaviour.

Lesson 3 • Atomic Variables and CAS Operations

Explains compare-and-swap as the hardware primitive underlying lock-free algorithms. Builds atomic counters, references, and stamped references.

Lesson 4 • Thread-Safe Collection Wrappers

Examines synchronised wrappers and their compound-operation pitfalls. Motivates purpose-built concurrent collections over naive wrapping.

Lesson 1 • Composable Async Pipelines

Chains dependent async computations using completable futures and continuation callbacks. Handles errors and fallbacks within the pipeline.

Lesson 2 • Executor Framework Architecture

Introduces the executor abstraction that decouples task submission from execution policy. Maps executor types to workload characteristics.

Lesson 3 • Futures, Callables, and Promises

Submits Callable tasks and retrieves results via Future, handling cancellation and timeout. Introduces Promise as the write side of a future.

Lesson 4 • Fork-Join and Work Stealing

Implements divide-and-conquer parallelism using the fork-join framework. Explains work-stealing scheduling and its throughput benefits.

Lesson 1 • Observable and Observer Contract

Defines the observable sequence, subscription lifecycle, and observer callbacks. Establishes the push-based data flow model central to reactive programming.

Lesson 2 • Reactive Streams Specification

Covers the four reactive streams interfaces: Publisher, Subscriber, Subscription, and Processor. Explains demand signalling as the foundation of back-pressure.

Lesson 3 • Building a Minimal Reactive Library

Implements a toy observable, subscription, and map operator from scratch. Solidifies understanding of the contract before using production libraries.

Lesson 4 • Back-Pressure Strategies

Compares drop, buffer, and throttle strategies for handling faster producers. Selects the appropriate strategy based on data loss tolerance and latency goals.

Lesson 1 • Combination Operators

Merges, zips, and combines multiple streams into unified outputs. Explains timing semantics that determine when combined emissions occur.

Lesson 2 • Transformation Operators

Covers map, flatMap, concatMap, and switchMap for value and stream transformation. Distinguishes ordering and concurrency guarantees of each operator.

Lesson 3 • Multicasting and Sharing Streams

Converts cold observables to hot using publish, share, and replay operators. Controls subscription timing and replay buffer size.

Lesson 4 • Error Handling and Recovery Operators

Implements retry, retryWhen, onErrorReturn, and onErrorResume for resilient pipelines. Distinguishes recoverable from terminal errors in stream context.

Lesson 1 • Eliminating Blocking Code

Identifies blocking calls that stall reactive threads and wraps them in deferred or fromCallable. Applies I/O schedulers to isolate blocking work.

Lesson 2 • subscribeOn and observeOn Operators

Explains how subscribeOn sets the subscription thread and observeOn switches the observation thread. Demonstrates correct placement for upstream and downstream threading.

Lesson 3 • Scheduler Types and Responsibilities

Catalogues computation, I/O, single-thread, and trampoline schedulers by their intended workload. Maps each scheduler to the correct pipeline stage.

Lesson 4 • Reactive Integration with Async I/O

Bridges callback-based and future-based async APIs into reactive streams. Covers TCP, HTTP, and database async drivers as integration targets.

Lesson 1 • Performance Profiling and Tuning

Profiles operator overhead, allocation rates, and thread contention using async profilers. Applies fusion, operator lifting, and pool tuning to reduce latency.

Lesson 2 • Observability and Metrics

Instruments reactive pipelines with latency histograms, error rates, and queue depth metrics. Connects metrics to alerting thresholds for production monitoring.

Lesson 3 • Testing Concurrent and Reactive Code

Uses virtual time schedulers, test subscribers, and deterministic concurrency tools to write reliable tests. Covers property-based testing for concurrent invariants.

Lesson 4 • Rate Limiting and Throttling

Applies token-bucket and leaky-bucket algorithms to cap emission rates. Prevents downstream overload while maintaining acceptable latency.