Concurrency in Practice - volatile ++

Question

In Concurrency in Practice, it says you can use volatile variables if

Writes to the variable do not depend on its current value.

So, if you have a shared, mutable variable a, and all threads ever do to it is go a++ (they don't get the value, they just ++).

Then according to the quote, you should be able to make it volatile even though a++ is not atomic, correct?

Answer 1

No, using ++ on a volatile variable is not threadsafe, because

a++

is equivalent to:

int temp = a;
temp = temp + 1;
a = temp;

So the write back to a may happen after another thread has modified a since your thread read it, so a++, even if a is volatile, is not threadsafe.

You can use AtomicInteger, which implements threadsafe atomic incrementation.

Answer 2

a++ reads the value of a, since it's equivalent to

• read a
• increment the read value
• assign the new value to a

So no, you can't safely use a volatile variable in this case.