JEP 193: Enhanced Volatiles

[Gernot Neppert]

Am 03.03.2014 20:26, schrieb mark.reinhold at oracle.com:
> Posted: http://openjdk.java.net/jeps/193
>
> - Mark


Reading about ideas to integrate atomic operations into the language, I 
was asking myself which of these operations I was using most frequently 
in my own code (currently by means of 
java.util.concurrent.atomic.AtomicXXX variables) and how they could be 
made more convenient with built-in support.
Here's my top 5 list:

1. AtomicReference.compareAndSet(T expect,T update). In almost all of 
the usecases, "expect" was null.

2. AtomicBoolean.compareAndSet(boolean expect, boolean update. In almost 
all of the usecases, "expect" was false.

3. AtomicReference.getAndSet(T update).

4. AtomicInteger.getAndIncrement().

5. AtomicInteger.getAndDecrement().

Now, 4. and 5. would be the easiest to solve: Make postfix "++" and "--" 
implicitly atomic if used on volatile variables. I know that this would 
require a change of the JLS, but on the other hand, the precise meaning 
of "volatile" has been changed once before, so would this be a showstopper?

For cases 1. and 2. one could think of a new operator "lhs ?= rhs" with 
the meaning
"Assign the rhs to the lhs only if lhs is currently null. Return true if 
the assignment took place (Alternatively, return rhs if the assignment 
took place. Would be more consistent with other assignment operators and 
convey the same amount of information as a boolean value).  Make the 
operation atomic if lhs is a volatile variable".

For case 3. one could devise an operator "lhs := rhs" with the meaning
"Assign the rhs to the lhs and return the previous content of the lhs. 
Make the operation atomic if lhs is a volatile variable".

Note that the new operators would have consistent meaning even if used 
with non-volatile variables (even though they wouldn't provide exciting 
new possibilities)