Volatile piggyback. Is this enough for visiblity?

Question

This is about volatile piggyback. Purpose: I want to reach a lightweight vars visibilty. Consistency of a_b_c is not important. I have a bunch of vars and I don't want to make them all volatile.

Is this code threadsafe?

class A {     public int a, b, c;     volatile int sync;      public void setup() {         a = 2;         b = 3;         c = 4;     }      public void sync() {         sync++;     } }  final static A aaa = new A();  Thread0: aaa.setup(); end  Thread1: for(;;) {aaa.sync(); logic with aaa.a, aaa.b, aaa.c}  Thread2: for(;;) {aaa.sync(); logic with aaa.a, aaa.b, aaa.c} 

Answer 1

Java Memory Model defines the happens-before relationship which has the following properties (amongst others):

• "Each action in a thread happens-before every action in that thread that comes later in the program order" (program order rule)
• "A write to a volatile field happens-before every subsequent read of that same volatile" (volatile variable rule)

These two properties together with transitivity of the happens-before relationship imply the visibility guarantees that OP seeks in the following manner:

1. A write to a in thread 1 happens-before a write to sync in a call to sync() in thread 1 (program order rule).
2. The write to sync in the call to sync() in thread 1 happens-before a read to sync in a call to sync in thread 2 (volatile variable rule).
3. The read from sync in the call to sync() in thread 2 happens-before a read from a in thread 2 (program order rule).

This implies that the answer to the question is yes, i.e. the call to sync() in each iteration in threads 1 and 2 ensures visibility of changes to a, b and c to the other thread(s). Note that this ensures visibility only. No mutual exclusion guarantees exist and hence all invariants binding a, b and c may be violated.

See also Java theory and practice: Fixing the Java Memory Model, Part 2. In particular the section "New guarantees for volatile" which says

Under the new memory model, when thread A writes to a volatile variable V, and thread B reads from V, any variable values that were visible to A at the time that V was written are guaranteed now to be visible to B.

Answer 2

Incrementing a value between threads is never thread-safe with just volatile. This only ensures that each thread gets an up to date value, not that the increment is atomic, because at the assembler level your ++ is actually several instructions that can be interleaved.

You should use AtomicInteger for a fast atomic increment.

Edit: Reading again what you need is actually a memory fence. Java has no memory fence instruction, but you can use a lock for the memory fence "side-effect". In that case declare the sync method synchronized to introduce an implicit fence:

void synchronized sync() {     sync++; }