Full round replay — volatile and synchronized

Pass: count++ is read, add, write. volatile makes each step visible without making the trio indivisible, so two threads read the same value and both write back the same increment. At scale most increments are lost.

Fail: Says it is only broken in rare interleavings, or that volatile makes it atomic.

Pass: Atomicity, visibility and ordering. volatile addresses visibility and ordering; only mutual exclusion or a CAS type gives atomicity.

Fail: Treats thread-safety as one undifferentiated problem.

Pass: No. The instance method locks `this`, the static method locks the Class object. Different monitors, no exclusion.

Fail: Says yes because both are synchronized and in the same class.

Pass: No — volatile protects the reference. Concurrent puts corrupt the map exactly as before. Either use ConcurrentHashMap, or keep volatile and replace the whole map with a new immutable copy on each write, which is right when reads dominate.

Fail: Accepts it, or says volatile makes the object thread-safe.

Pass: Without it the write publishing the reference can be reordered ahead of the writes initialising the object, so another thread sees a non-null reference to a half-constructed object. That is ordering, not visibility.

Fail: Says it is about visibility, or that volatile is optional there.

Pass: No conclusion follows. A visibility bug depends on the JIT, core count and the CPU's memory model — it can hide for years and surface on a different architecture. Correctness is argued with happens-before, not demonstrated by a green run.

Fail: Treats the passing test as evidence of safety.

Pass: A one-way flag one thread writes and others read; safe publication of an immutable object; and double-checked locking. Nothing involving a read-modify-write.

Fail: Cannot name a legitimate use, or names a counter.

Pass: CAS retries when the swap fails, so at high contention an atomic can burn CPU losing races while a lock parks the thread and lets one winner through. Default to the atomic, measure before deciding.

Fail: Says atomics are always faster.

Pass: Neither field being atomic helps — an invariant over two fields needs one critical section over both, or a single immutable object holding the pair swapped atomically.

Fail: Adds more atomics, or makes both volatile.