Concurrency and Parallelism in Java

In this section

• Introduction to Concurrent Programming in Java
  Learn the core Java concurrency model, how concurrency differs from parallelism, and why coordination cost matters as much as thread count.
• Java Memory Model and Thread Behavior
  Understand the Java Memory Model so visibility, ordering, atomicity, and happens-before rules stay explicit in concurrent code reviews.
• Locks and Synchronization
  Choose Java locking and synchronization primitives that protect shared state without creating hidden contention or brittle coordination.
  • Advanced Locking Mechanisms
    Use advanced Java locks when intrinsic synchronization is too blunt and you need clearer control over fairness, read/write access, or optimistic reads.
    • ReentrantLock in Java
      Use `ReentrantLock` in Java when interruption, timed acquisition, fairness, or explicit lock management matter more than `synchronized` simplicity.
    • ReentrantReadWriteLock in Java
      Use `ReentrantReadWriteLock` in Java when read-heavy contention patterns justify separate read and write access paths.
    • StampedLock in Java
      Use `StampedLock` in Java for optimistic reads and specialized contention patterns when simpler locking is too coarse.
    • Optimistic Locking Techniques in Java Concurrency
      Use optimistic locking techniques in Java when read-mostly access patterns justify retries and validation over heavier lock contention.
  • Synchronizers in `java.util.concurrent`
    Use Java synchronizers such as latches, barriers, semaphores, phasers, and exchangers when threads must coordinate phases or resource access explicitly.
    • CountDownLatch in Java
      Use `CountDownLatch` in Java when one thread must wait for a fixed number of one-time events or worker completions.
    • CyclicBarrier in Java
      Use `CyclicBarrier` in Java when a fixed group of worker threads must repeatedly meet at the same phase boundary.
    • Semaphore in Java
      Use `Semaphore` in Java to bound concurrent access to scarce resources and make admission control explicit.
    • Exchanger in Java
      Use `Exchanger` in Java when two threads need a rendezvous point to swap data without broader shared-state coordination.
    • Phaser in Java
      Use `Phaser` in Java when participants can register dynamically across multiple synchronization phases instead of staying fixed.
  • Understanding the `volatile` Keyword and Atomic Variables in Java Concurrency
    Understand when `volatile` is enough in Java, when atomic variables are better, and when neither replaces real synchronization.
• Concurrent Collections in Java
  Choose concurrent maps, queues, and copy-on-write collections in Java when shared access is unavoidable and each structure's trade-offs are clear.
• Executors and Thread Pools
  Choose Java executors, pool types, and queueing strategies that match workload shape instead of treating all task execution as interchangeable.
  • Understanding Executors and Thread Pools in Java
    Understand how Java executors and thread pools separate task submission from execution policy, queueing, and overload behavior.
  • Using `ExecutorService` in Java
    Use `ExecutorService` to submit, manage, and shut down concurrent Java work cleanly without leaking tasks or hiding lifecycle ownership.
  • Scheduled Executors in Java
    Use scheduled executors in Java for delayed and periodic work, and choose the right scheduling mode to avoid drift, overlap, or backlog surprises.
  • Custom Thread Pools in Java
    Build custom Java thread pools only when workload isolation, naming, queueing, or rejection policy needs justify more than the defaults.
  • Tuning `ThreadPoolExecutor` in Java
    Tune Java `ThreadPoolExecutor` settings with queue size, pool bounds, and rejection policy aligned to real workload behavior.
• Futures and Callables in Java
  Use `Future` and `Callable` in Java for deferred task results, and understand where they stop short compared with richer async models.
• Fork/Join Framework
  Use Java's Fork/Join framework for recursive divide-and-conquer workloads where work stealing improves CPU-bound parallel execution.
  • RecursiveTask and RecursiveAction in Java Fork/Join Framework
    Choose between `RecursiveTask` and `RecursiveAction` in Java based on whether recursive parallel work returns a value or only performs side effects.
  • Parallelism with Fork/Join in Java
    Use Fork/Join in Java for recursive CPU-bound work where task splitting and work stealing outperform simpler executor strategies.
• Asynchronous Programming with `CompletableFuture`
  Use `CompletableFuture` in Java for staged async workflows, fan-out and join patterns, and explicit failure handling across task graphs.
  • Composing `CompletableFuture` Workflows in Java
    Compose Java `CompletableFuture` stages for fan-out, joins, and dependent async work without hiding control flow or failure handling.
  • Exception Handling in `CompletableFuture` Code
    Handle errors in Java `CompletableFuture` chains without losing causality, swallowing failures, or leaving partial async work behind.
• Parallel Streams
  Use parallel streams in Java when data-parallel work is large and independent enough to justify Fork/Join overhead and ordering constraints.
  • Using Parallel Streams in Java
    Use Java parallel streams when data-parallel work is large, independent, and cheap to combine, not merely because the API makes it easy.
  • Performance Considerations for Parallel Streams in Java
    Evaluate workload size, split cost, merge overhead, and shared-state risk before using Java parallel streams for performance gains.
• Reactive and Asynchronous Models
  Compare Java reactive and asynchronous models so event streams, async workflows, and backpressure concerns are handled with the right abstraction.
  • Introduction to Reactive Programming in Java
    Learn the core reactive programming model in Java and when event-driven, non-blocking flows are worth the extra abstraction.
  • Asynchronous Data Streams in Java
    Use asynchronous data streams in Java when publishers, subscribers, and demand management fit the workload better than request-style concurrency.
  • Composing Complex Asynchronous Workflows in Java
    Compose complex asynchronous Java workflows with clear merge, retry, and failure boundaries instead of letting reactive chains become opaque.
• Avoiding Deadlocks and Race Conditions
  Prevent deadlocks, races, and visibility bugs in Java by designing safer shared-state boundaries before adding more synchronization.
  • Detecting Deadlocks in Java
    Detect deadlocks in Java with thread dumps, diagnostics, and lock-order reasoning so failures are explainable instead of intermittent mysteries.
  • Best Practices for Safe Concurrent Programming in Java
    Apply practical Java concurrency habits that reduce shared-state risk, clarify ownership, and make deadlocks and races less likely by design.
• Designing Concurrent Java Systems for Performance and Scalability
  Design concurrent Java systems around bottlenecks, queueing, throughput limits, and resource ownership instead of chasing parallelism by default.