Concurrency and Parallelism in Clojure

This section covers the part of Clojure that most clearly distinguishes it from many other JVM languages: explicit, well-separated concurrency models. Instead of one generic shared-memory story, Clojure gives you several tools for different coordination problems, from atomic updates to coordinated transactions and asynchronous pipelines.

The goal here is to learn not just how these primitives work, but when each one is the right fit and what kinds of bugs or performance problems show up when they are mixed carelessly.

The quickest way to read this chapter well is to separate the problems before you separate the code:

• use atoms when one value changes independently
• use refs when several values must preserve an invariant together
• use agents when updates should happen asynchronously
• use futures and reducers for parallel computation
• use channels when ownership and message flow are the main story

That framing matters more than memorizing APIs. Most Clojure concurrency mistakes come from choosing the wrong coordination model first and trying to tune the consequences later.

In this section

• Concurrent Programming in Clojure
  Understand how Clojure uses immutable data, coordinated state models, and message-passing tools to make concurrency safer without hiding the real trade-offs.
• Software Transactional Memory (STM) with Refs in Clojure
  Learn when refs and STM fit, how dosync, alter, commute, and ensure differ, and how to avoid side-effect and contention mistakes in coordinated Clojure state updates.
• Managing Shared State with Atoms in Clojure
  Learn when atoms fit, how swap! retries work, and how to use validators, watches, and compare-and-set! safely in concurrent Clojure code.
• Asynchronous Programming with Agents in Clojure
  Learn when agents fit, how send and send-off differ, and how to handle errors, shutdown, and transaction boundaries in asynchronous Clojure state updates.
• core.async and Channels: Mastering Asynchronous Communication in Clojure
  Learn how channels, go blocks, buffers, alts!, and blocking boundaries really work in core.async, including the practical difference between parking and blocking operations.
• Clojure Parallel Processing: Mastering `pmap` and `future`
  Learn when `pmap` helps, when `future` is the better tool, and why parallelism only pays off for the right workload shape in Clojure.
• Designing for Performance and Scalability in Clojure
  Learn how to design Clojure systems for throughput and latency by reducing coordination, measuring bottlenecks, and choosing the right data and execution boundaries.
• Avoiding Deadlocks and Race Conditions in Clojure Concurrency
  Learn how Clojure reduces race conditions, where deadlocks can still appear, and how to choose atoms, refs, agents, and interop boundaries safely.
• Asynchronous Programming Patterns in Clojure: Mastering Concurrency with Core.Async and More
  Learn how to choose among futures, promises, agents, channels, and callback handoff patterns in Clojure based on the real interaction shape.
• Implementing Event Loops in Clojure: Mastering Asynchronous Programming
  Learn how to build event loops in Clojure with channels, dispatch maps, and blocking boundaries that keep the loop responsive under load.
• Actor Model in Clojure: Harnessing Concurrency for Robust Applications
  Learn what the actor model promises, how Clojure approximates it with agents and channel mailboxes, and when a dedicated actor runtime is or is not justified.
• Lock-Free and Wait-Free Programming in Clojure: Advanced Concurrency Techniques
  Learn what lock-free and wait-free really mean, where Clojure uses CAS-based lock-free techniques, and why most application code should prefer higher-level concurrency models.
• Communicating Sequential Processes (CSP) Model in Clojure
  Learn the core ideas of CSP, how core.async approximates them in Clojure, and where explicit channel communication beats shared mutable state.
• Utilizing Thread Pools for Efficient Concurrency in Clojure
  Learn how futures, agents, executors, and core.async interact with thread pools, and how to size pools by workload type without creating starvation.
• Synchronization Primitives and Their Use Cases in Clojure
  Explore synchronization primitives in Clojure and Java, including locks and semaphores, and understand their use cases and best practices.
• Fork-Join Pattern in Clojure: Mastering Parallel Computation
  Explore the Fork-Join Pattern in Clojure for efficient parallel computation. Learn to split tasks into subtasks, implement using fork/join pools, and optimize performance.
• Reactor Pattern with core.async for Scalable Event-Driven Applications
  Learn how to model the Reactor pattern in Clojure with channels and dispatch loops, and how to keep the reactor non-blocking without confusing it with general-purpose background work.
• Pipeline Pattern for Data Processing in Clojure
  Learn how to design channel-driven data pipelines in Clojure with clear stage ownership, bounded buffers, and the right choice among pipeline variants.
• Handling Backpressure in Async Systems: Strategies for Flow Control in Clojure
  Learn how to design explicit backpressure policies with core.async using bounded channels, dropping and sliding buffers, worker limits, and timeout-based overload handling.
• Transactional Memory Patterns in Clojure: Mastering Concurrency with STM
  Learn the most useful STM patterns in Clojure, including coordinated updates, commutative counters, consistent reads, and transaction-safety rules.
• Clojure Parallelism with Reducers: Unlocking Efficient Data Processing
  Learn what reducers are actually for, when fold-based parallel reduction helps, and why reducers are best for large CPU-bound associative workloads rather than general-purpose pipeline code.
• Advanced Patterns in core.async: Mastering Asynchronous Programming in Clojure
  Learn how to use channel transducers, mult, mix, pub, merge, and selection in core.async without turning channel topology into accidental complexity.