Why is AtomicInteger needed if writes and reads to int variables are atomic?

Question

I've read in Oracle docs that:

• Reads and writes are atomic for reference variables and for most
  primitive variables (all types except long and double).

(I guess this feature has been added in some new JDK release because I used to think that reads/writes of ALL primitive variables are NOT atomic)

Does it mean that AtomicInteger is deprecated and shouldn't be used in new projects?

Answer 1

While a single store to or a single load from an ordinary int is atomic in Java, you cannot atomically, say, increment it. Doing so would require you to first load the value, then compute the new value depending on it and then store the new value back. But between the two accesses, another thread might have modified the value. AtomicInteger provides operations like getAndIncrement that can be used for this purpose without having to use a lock.

Answer 2

Deprecated? Not at all. While individual reads and writes of primitive variables are atomic, AtomicInteger (and the other atomic classes in java.util.concurrent.atomic) provides more complex operations that are also atomic. These include things like addAndGet(int), which are not at all atomic for primitive int variables. Thus,

int i = 3;
AtomicInteger j = new AtomicInteger(3);
i += 5; // NOT thread-safe -- might not set i to 8
int n = j.addAndGet(5); // thread-safe -- always sets n to 8

(Both of the comments above are under the assumption that i and j are not changed by the time the statement in question starts executing, but might be changed by another thread after execution starts but before it is finished.)