8.7.1 Implementing a Shared Counter with Atoms

Concurrency Made Easy: Implementing a Shared Counter with Clojure’s Atoms

In this section, we’ll explore how to implement a thread-safe shared counter using Clojure’s atom construct. Atoms in Clojure provide a mechanism for managing shared, mutable state with an emphasis on safety and simplicity—an ideal tool to handle concurrency challenges without relying on traditional locks.

Understanding Atoms

Atoms provide a way to define and manage mutable state. Unlike typical variables, atoms ensure changes are made in a thread-safe manner using compare-and-swap (CAS) operations. This approach avoids the pitfalls of conventional locking mechanisms, leading to cleaner and more efficient code.

Implementing the Counter

Step 1: Define an Atom

We’ll start by defining an atom to store our shared counter:

(def counter (atom 0))

In this code snippet, atom initializes the counter to zero. The atom provides atomic operations, ensuring thread-safe increments.

Step 2: Increment the Counter

To increment the counter safely, we’ll use swap!, which applies a function to the atom’s value atomically.

(defn increment-counter []
  (swap! counter inc))

The swap! function atomically applies inc, the increment function, to the current value of counter.

Step 3: Simulate Concurrent Increments

Let’s simulate a scenario where multiple threads increment the counter simultaneously:

(defn simulate-concurrent-increments [n]
  (let [threads (doall (repeatedly n #(Thread. increment-counter)))]
    (doseq [t threads]
      (.start t))
    (doseq [t threads]
      (.join t))))

Here, we create and start n threads to execute increment-counter concurrently, then wait for their completion using .join.

Step 4: Verify Counter Value

Finally, check the counter’s value to ensure all increments have been accounted for:

(simulate-concurrent-increments 1000)
(println "Final counter value:" @counter) ; Should output 1000

This print statement confirms that despite concurrent operations, the counter reached the expected value, demonstrating the power of atoms.

Comparing Java and Clojure Approaches with Diagrams

Java Example

import java.util.concurrent.atomic.AtomicInteger;

AtomicInteger counter = new AtomicInteger(0);

Runnable task = () -> counter.incrementAndGet();

Thread[] threads = new Thread[1000];
for (int i = 0; i < 1000; i++) {
    threads[i] = new Thread(task);
    threads[i].start();
}

for (Thread t : threads) {
    t.join();
}

System.out.println("Final counter value: " + counter.get());

Mermaid Diagram

    sequenceDiagram
	  participant Main
	  participant Task as Thread Task
	  Main->>Task: Start
	  Task-->>Counter: Increment
	  Main-->>Task: Wait for Completion
	  Task->>Counter: Final Check
	  Main->>Console: Print Result

Quiz

By understanding and implementing atoms in Clojure, you gain an essential tool to writing concurrent applications with simplicity and grace—key to functional programming’s appeal.