CODEWITHSUNDEEP
javavolatile
roland luo
roland luo

Reputation: 1631

I am confused, is volatile really useful?

I wrote an example trying to understand volatile.

public class VolatileExample {

private volatile boolean close = false;

public void shutdown() {
    close = true;
}

public void work(){

    Thread t1 = new Thread(new Runnable(){
        public void run(){
            while (!close) {

            }
        }
    });

    Thread t2 = new Thread(new Runnable(){
        public void run(){
            while (!close) {
                shutdown();
            }
        }
    });

    t1.start();
    t2.start();
    try {
        t1.join();
        t2.join();
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }   
}

public static void main(String[] args){
    VolatileExample volatileExample = new VolatileExample();
    volatileExample.work();
}   
}

it did stop as I expected. However, when I took the volatile away from the close tag, I have tried a lot of times---I expect the program will not stop because the thread t1 cannot see the change made by thread t2 on the close variable, but the programs ended successfully everytime. So I am confused, now that we can do it without volatile, what is volatile used for? Or can you give a better example that can make a difference between using volatile and not using volatile?

Thank you!

Upvotes: 3

Views: 115

Answers (2)

Warren Dew
Warren Dew

Reputation: 8928

Changes to nonvolatile fields are sometimes visible to other threads, and sometimes not. How long they take to be visible to other threads can vary by orders of magnitude depending on what other processing the machine is doing, the number of processor chips and cores on the machine, the architecture of the cache memory on the machine, etc.

Ultimately, though, it comes down to this: buggy concurrency code can succeed the first 999,999 times, and fail on the millionth time. That often means it passes all tests, then fails in production when things really matter. For that reason, it's important when writing concurrent code that one make the best possible effort to ensure the code is correct - and that means using volatile for variables accessed from multiple threads even when it doesn't seem to make a difference in testing.

Upvotes: 2

Bohemian
Bohemian

Reputation: 424993

The memory model says only that changes to non- volatile fields may not be visible in other threads.

Perhaps your runtime environment was in a cooperative mood.

Upvotes: 7

Related Questions