atomicboolean

I was trying to cut thread contention in my code by replacing some synchronized blocks with AtomicBoolean . Here's an example with synchronized : public void toggleCondition() { synchronized (this.mutex) { if (this.toggled) { return; } this.toggled = true; // do other stuff } } And the alternative with AtomicBoolean : public void toggleCondition() { if (!this.condition.getAndSet(true)) { // do other stuff } } Taking advantage of AtomicBoolean 's CAS property should be way faster than relying on synchronization so I ran a little micro-benchmark . For 10 concurrent threads and 1000000 iterations

What does AtomicBoolean do that a volatile boolean cannot achieve? They are just totally different. Consider this example of a volatile integer: volatile int i = 0; void incIBy5() { i += 5; } If two threads call the function concurrently, i might be 5 afterwards, since the compiled code will be somewhat similar to this (except you cannot synchronize on int ): void incIBy5() { int temp; synchronized(i) { temp = i } synchronized(i) { i = temp + 5 } } If a variable is volatile, every atomic access to it is synchronized, but it is not always obvious what actually qualifies as an atomic access.