What is Volatile in Java and when/how should we use them?

Question

public class Volatile {

    volatile int x = 0;

    public static void main(String a[]) {
        Volatile y = new Volatile();
        test t1 = new test(y);
        test t2 = new test(y);
        t1.setName("A");
        t2.setName("B");
        t1.start();
        t2.start();
    }
}

class test extends Thread {

    Volatile v;

    test(Volatile v) {
        this.v = v;
    }

    @Override
    public void run() {
        for (int i = 0; i < 4; i++) {
            System.out.println(Thread.currentThread().getName() + "Says Before " + v.x);
            v.x++;
            System.out.println(Thread.currentThread().getName() + "Says After " + v.x);
        }
    }
}

Output

ASays Before 0
BSays Before 0
BSays After 2
BSays Before 2
BSays After 3
ASays After 1   <--- Is it a cache value ?
BSays Before 3
ASays Before 3
BSays After 4
BSays Before 5
BSays After 6
ASays After 5    <--- Is it a cache value ?
ASays Before 6
ASays After 7
ASays Before 7
ASays After 8

Everywhere, I found common point about volatile

guaranteeing that it will not be cached and that different threads will see the updated value

But, from my above example, threads have different values (old/cache values) or is it because of improper implementation ?

Answer 1

Marking a variable volatile will prevent the JVM from caching the value but it will not take care of synchronisation issues for you (such as the thread being swapped out between modifying the variable and printing it).

For example, thread A outputs before 0 then is swapped out so that thread B runs. The value is still zero because A hasn't yet updated it. B then updates it and then A comes back in and updates it as well, then prints it. That means you could end up with something like:

ASays Before 0
BSays Before 0
ASays After 2

which is less than ideal.

In addition, the println itself is not atomic so it can be interrupted mid-stream, causing the thread to be holding an outdated value for printing (i.e., one that shows up later in the output stream thatn it would ideally).

To properly update and print, you should use synchronized around blocks that require the variable to be used atomically, something like:

synchronized (this) {
    System.out.println(Thread.currentThread().getName() + " before " + v.x);
    v.x++;
    System.out.println(Thread.currentThread().getName() + " after " + v.x);
}

In your particular case however, you cannot use this since it's the thread object, meaning that there's two of them, hence they won't block each other as you need.

You can get around that with a bit of a kludge, introducing a static object into the thread class:

static Object o = new Object();

and using that for synchronisation:

synchronized (o) {
    System.out.println(Thread.currentThread().getName() + " before " + v.x);
    v.x++;
    System.out.println(Thread.currentThread().getName() + " after " + v.x);
}