How atomicity is achieved in the classes defined in java.util.concurrent.atomic package?

Question

I was going through the source code of java.util.concurrent.atomic.AtomicInteger to find out how atomicity is achieved by the atomic operations provided by the class. For instance AtomicInteger.getAndIncrement() method source is as follows

public final int getAndIncrement() {
    for (;;) {
        int current = get();
        int next = current + 1;
        if (compareAndSet(current, next))
            return current;
    }
}

I am not able to understand the purpose of writing the sequence of operations inside a infinite for loop. Does it serve any special purpose in Java Memory Model (JMM). Please help me find a descriptive understanding. Thanks in advance.

Answer 1

I am not able to understand the purpose of writing the sequence of operations inside a infinite for loop.

To understand why it is in an infinite loop I find it helpful to understand what the compareAndSet does and how it may return false.

Atomically sets the value to the given updated value if the current
value == the expected value.

 Parameters:
     expect - the expected value
     update - the new value 
 Returns:
     true if successful. False return indicates that the actual value was not
     equal to the expected value

So you read the Returns message and ask how is that possible?

If two threads are invoking incrementAndGet at close to the same time, and they both enter and see the value current == 1. Both threads will create a thread-local next == 2 and try to set via compareAndSet. Only one thread will win as per documented and the thread that loses must try again.

This is how CAS works. You attempt to change the value if you fail, try again, if you succeed then continue on.

Now simply declaring the field as volatile will not work because incrementing is not atomic. So something like this is not safe from the scenario I explained

volatile int count = 0;

public int incrementAndGet(){
   return ++count; //may return the same number more than once.
}