Can AtomicInteger replace synchronized?

Question

The javadoc for the java.util.concurrent.atomic package says the following:

A small toolkit of classes that support lock-free thread-safe programming on single variables.

But I don't see any thread-safe (synchronized or Lock) code inside any of the AtomicInteger or AtomicBoolean classes.

So, are these 2 the same:

1.

int i;
synchronized(this){i++;}

2.

AtomicInteger i = new AtomicInteger();
i.getAndIncrement();

Update: Thanks for the answers. Is volatile needed when I use AtomicInteger?

Answer 1

They would offer the same atomicity. The only thing you must be aware of is any time you read i you must wrap it with synchronized also

synchronized(this){ return i;}

Edit to answer your edit:

Volatile is not necessary for your AtomicInteger. To prove that declare the AtomicInteger final. The only reason you would need the AtomicInteger to be volatile is if the AtomicInteger field itself changes. Similar to:

volatile AtomicInteger i = new AtomicInteger(0);

public void work(){
    i.incrementAndGet();
    //...do some other stuff
    i = new AtomicInteger(10);//because the field i is changing the field needs to be volatile 
}

As you can imagine that shouldn't be the case, so you shouldn't have to worry about the field being volatile.

Answer 2

They are equivalent functionally, but there is a subtle difference. synchronized has the overhead of acquiring and releasing the monitor on this, while AtomicInteger is implemented with a native method call, so it will be significantly faster.