Refs, Agents und Atoms für Zustände

Managing state in concurrent programs is tricky! When multiple parts of your code try to change the same data at once, you can run into big problems like data corruption or deadlocks.

Clojure offers powerful tools to handle shared mutable state safely and efficiently.

Clojure embraces immutability by default. This means data structures don't change after creation. But what about when you genuinely need to change something, like a counter or a user's balance?

• Clojure provides special concurrency primitives.
• These primitives manage mutable state in a controlled way.
• They ensure changes are safe, even across multiple threads.

An Atom is the simplest way to manage a single, independent piece of mutable state. It's great for things like counters or flags.

• Updates are synchronous and atomic (all-or-nothing).
• Atoms use a Compare-And-Swap (CAS) loop internally.
• Best for state that doesn't need to be coordinated with other pieces of state.

Let's see an Atom in action. We'll create a simple counter and update it.

The swap! function is key for updating Atoms:

• It takes the atom, a function, and optional arguments for that function.
• (swap! my-atom inc) atomically increments the value.
• (swap! my-atom + 5) atomically adds 5 to the value.
• The function is applied to the atom's current value, and the result becomes the new value. This happens in a thread-safe way.

Refs are for managing coordinated mutable state. This means you have multiple pieces of state that must change together, or not at all.

• Refs use Clojure's Software Transactional Memory (STM).
• Changes occur within a transaction (dosync block).
• All changes in a transaction either succeed or fail as a group.

Here's how to use Refs to transfer a value between two accounts atomically. If one fails, both revert.

The dosync block defines a transaction:

• ref creates a new Ref.
• alter changes a Ref's value within a transaction. It takes the Ref, a function, and its arguments.
• If any part of the dosync block fails, all changes are rolled back.
• This ensures atomicity: all or nothing.

Agents are designed for managing mutable state asynchronously and in isolation. They're perfect for tasks that might take time or run in the background without blocking your main thread.

• Updates are sent as messages to the Agent.
• The Agent processes these messages in a separate thread.
• This provides isolation: the agent's state changes only through its own processing.

Let's use an Agent to process a list of numbers asynchronously, summing them up.

Here's how Agents work:

• agent creates a new Agent with an initial value.
• send dispatches a function and arguments to the agent. The function will be applied to the agent's current state on another thread.
• The agent processes messages one by one in its own thread, ensuring isolated updates.
• await (or await-for) is used to block the current thread until the agent has processed all pending actions.

You've learned about Atoms, Refs, and Agents. Each has a specific purpose for managing mutable state safely.

Which of the following statements correctly describe when to use which concurrency primitive?

In this lesson, we explored Clojure's core concurrency primitives for managing mutable state safely:

• Atoms: For simple, independent, synchronous state changes.
• Refs: For coordinated, transactional state changes across multiple values using STM.
• Agents: For asynchronous, isolated state updates, processed in a separate thread.

Understanding these tools is crucial for building robust and concurrent Clojure applications!