Difference between getAndSet and compareAndSet in AtomicBoolean

Question

The thread title should be self-explnatory... I'm a bit confused between the specification of below methos from AtomicBoolean class:

• java.util.concurrent.atomic.AtomicBoolean#compareAndSet
• java.util.concurrent.atomic.AtomicBoolean#getAndSet

My assemption is that both would result in the same behavior when used as a boolean clause in an if condition:

public class Test {
  private AtomicBoolean flag = AtomicBoolean(false);

  public void processSomeAction() {
    if (flag.getAndSet(false)) { // Shouldn't this be similar to flag.compareAndSet(false)
      // process some action
    }
  }
  //...
  private void internalMutatorMethod() {
    // do some staff then update the atomic flag
    flas.set(true);
  }
}

Assuming that I want to retrieve the current flag value and update it automaticlly, shouldn't both methods produce the same behavior?

I would much appreciate any explanations regarding how and when to use each of those if I'm missing internal differences.

Answer 1

The documentation is pretty clear.

• getAndSet --> "Atomically sets to the given value and returns the previous value."
• compareAndSet --> "Atomically sets the value to the given updated value if the current value == the expected value."

Not surprisingly, compareAndSet takes two arguments.

In your specific case:

• if (flag.getAndSet(false)) will set flag to false only if its previous value was true
• That would be the equivalent of if (flag.compareAndSet(true, false))

Answer 2

You can look at the code for better understanding :

public final boolean getAndSet(boolean newValue) {
    for (;;) {
        boolean current = get();
        if (compareAndSet(current, newValue))
            return current;
    }
}

In getAndSet , if the value of the boolean has changed between the time you get() the old value and the time you try to change its value, compareAndSet won't change its value. Therefore, getAndSet calls compareAndSet in a loop until the boolean is set to the new value.

As to your code example :

flag.getAndSet(false) returns the old value of the AtomicBoolean. On the other hand, flag.compareAndSet(x,false) (note there are two arguments) returns whether the AtomicBoolean was modified, or in other words, it returns whether the old value of the AtomicBoolean was x.

Answer 3

When I have checked the implementation I found following

public final boolean getAndSet(boolean newValue) {
    for (;;) {
        boolean current = get();
        if (compareAndSet(current, newValue))
            return current;
    }
}

Also when checking the javadoc, compareAndSet sets value only if the comparison pass while getAndSet simply set the value and return the previous value.

Answer 4

The thread is a bit old but nobody mentioned that getAndSet will be more efficient than compareAndSet. CAS is a very costly instruction (on all CPU architectures, so JVM does not matter here). So they are not really equivalent.

So regarding the OP, both methods produce the same behaviour but it will not have the same performance, use getAndSet when you can.