Question

Suppose two following counter implementations:

class Counter {
  private final AtomicInteger atomic = new AtomicInteger(0);
  private int i = 0;

  public void incrementAtomic() {
    atomic.incrementAndGet();
  }

  public synchronized void increment() {
    i++;
  }
}

At first glance atomics should be faster and more scalable. And they are, I believe. But are they faster than synchronized blocks all the time? Or some situations exists when this rule is broken (e.g. SMP/Single CPU machine, different CPU ISA, OS’es etc.)?

Answer 1

incrementAndGet may well be implemented as a CAS-loop. In highly contented situations that can result in n-1 of your threads failing leading to an O(n) problem, for n threads.

( For @Geek:

Typically getAndIncrement may be implemented something like:

 int old;
 do {
     old = value;
 } while (!compareAndSet(value, old, old+1));
 return old;

Imagine you have a n threads executing this code on the same atomic, and they happen to be in step with each other. The first iteration does kn work. Only one CAS will succeed. The other n-1 threads will repeat the exercise until there is only one left. So the total work is O(n^2) (worst case) instead of O(n). )

Having said that, acquiring a lock will need to do something similar at best, and locks aren’t at their best when heavily contended. You’re not likely to see much of an advantage for locks until you use a CAS-loop which requires significant computation before get and compareAndSwap.