java.util.concurrent

CAS is a single atomic hardware instruction: it writes a new value only if the memory still holds the expected old one, and fails otherwise. AtomicInteger.incrementAndGet() reads the value, computes old + 1, and retries the CAS in a loop until it wins. No thread ever blocks — a loser just re-reads and tries again, so there is no lock and no context switch.

Both are reentrant mutual-exclusion locks, but ReentrantLock is an explicit object, so it can add what a block cannot: tryLock() with a timeout, an interruptible acquire, an optional fair queue, and several Condition objects. The price is manual discipline — you must call unlock() in a finally block, whereas synchronized releases automatically when the block exits.

Reentrancy means a thread already holding a lock can acquire it again instead of deadlocking on itself. The lock tracks the owning thread plus a hold count: each re-acquire increments it and each release decrements it, freeing the lock only when the count returns to zero. Both synchronized and ReentrantLock are reentrant, so one synchronized method can safely call another on the same object.

Collections.synchronizedList() wraps a list so that one lock guards every method: reads block each other, and iteration must still be synchronized by hand. CopyOnWriteArrayList copies the backing array on each write, so reads take no lock at all and every iterator sees an immutable snapshot.

Reads take no lock: the table and its nodes are volatile, so get() simply walks the bin. A write locks only the head node of the one bin it hashes to, so writers landing in different bins proceed in parallel, and an empty bin is filled with a compare-and-swap instead. Java 8 replaced Java 7's fixed segment array with this per-bin locking.

An intrinsic monitor gives an object exactly one wait set, so producers and consumers queue together and notifyAll() has to wake everyone just to reach the right thread. A ReentrantLock can create several Condition objects, each its own wait set, so notFull.signal() wakes only producers. await()/signal() otherwise mirror wait()/notify() and demand the lock be held.

A CountDownLatch is one-shot and one-directional: waiters block in await() until other threads drive the count to zero with countDown(), and it can never be reset. A CyclicBarrier is a rendezvous of N parties that wait for each other; when the last one arrives all are released, an optional barrier action runs, and the barrier resets for the next round.

It replaces hand-rolled monitor code with tested building blocks: explicit locks, atomics, concurrent collections, executor pools and synchronizers. You compose ready primitives instead of writing wait/notify loops yourself.

A thread reads value A, stalls while another thread changes it to B and back to A, then its CAS succeeds even though the state it reasoned about is gone — in a lock-free stack a popped node can be recycled and re-linked, corrupting the list. The fix is to version the reference: AtomicStampedReference pairs it with a counter, so the CAS compares both and fails after any intervening change.