CAS & Atomic Primitives

Two threads run the CAS loop — read → compute → compare-and-swap → retry — on one shared variable. Watch one thread succeed and the other fail and retry. Switch to ABA mode to see a value go A→B→A and fool a naive CAS — then enable the version tag to defeat it.

CAS: O(1) per attempt Loop: O(retries) under contention fetch-add: wait-free CAS loop: lock-free

Slow Fast

Thread A

old = –

f(old) = –

idle

shared

Thread B

old = –

f(old) = –

idle

Step

0/0

CAS success

CAS retries

Shared value

What is happening

Press Start to run the animation, or Step to advance one micro-step at a time.

read

compute

CAS success

CAS fail / retry

ABA value

Atomic operation reference
Operation	Effect (atomic)	Returns	Progress
`load`	read the value	value	wait-free
`store`	write the value	—	wait-free
`fetch-add(d)`	v += d	old v	wait-free
`exchange(x)`	v = x	old v	wait-free
`CAS(exp,new)`	if v==exp then v=new	success?	—
`CAS loop`	read, compute, CAS, retry	—	lock-free

Operation Log

Counter mode: both threads run for { old=load(); if CAS(old, old+1) break }. Only one CAS per contested value can succeed; the loser re-reads the new value and retries — no increment is ever lost. ABA mode: Thread B changes the value A→B→A while Thread A is paused mid-loop; A's CAS then wrongly succeeds because the value looks unchanged. A version tag makes every change unique, so A's stale CAS fails as it should.