Java volatile variable doesn't behave correctly.

Question

public class MyThread
{
    volatile static int i;

    public static class myT extends Thread
    {
        public void run ()
        {
            int j = 0;
            while(j<1000000){
                i++;
                j++;
            }
        }
    }

    public static void main (String[] argv)
    throws InterruptedException{
            i = 0;

            Thread my1 = new myT();
            Thread my2 = new myT();
            my1.start();
            my2.start();

            my1.join();
            my2.join();

            System.out.println("i = "+i);
    }
}

Since volatile builds happens-before relationship, the final value of i should be strictly 2000000. However, the actual result is nothing different from being without volatile for variable i. Can anyone explanation why it doesn't work here? Since i is declared volatile, it should be protected from memory inconsistency.

Community · Accepted Answer · 2017-05-23 10:25:44Z

10

Can anyone explanation why it doesn't work here? Since i is declared volatile, it should be protected from memory inconsistency.

It is protected but unfortunately i++ is not an atomic operation. It is actually read/increment/store. So volatile is not going to save you from the race conditions between threads. You might get the following order of operations from your program:

thread #1 reads i, gets 10
right afterwards, thread #2 reads i, gets 10
thread #1 increments i to 11
thread #2 increments i to 11
thread #1 stores 11 to i
thread #2 stores 11 to i

As you can see, even though 2 increments have happened and the value has been properly synchronized between threads, the race condition means the value only went up by 1. See this nice looking explanation. Here's another good answer: Is a volatile int in Java thread-safe?

What you should be using are AtomicInteger which allows you to safely increment from multiple threads.

static final AtomicInteger i = new AtomicInteger(0);
...
        for (int j = 0; j<1000000; j++) {
            i.incrementAndGet();
        }

edited May 23, 2017 at 10:25

CommunityBot

11 silver badge

answered Apr 29, 2013 at 23:41

Gray

117k24 gold badges305 silver badges360 bronze badges

Sign up to request clarification or add additional context in comments.

13 Comments

Mel Nicholson Over a year ago

Only i needs to be an AtomicInteger; j is purely local to the thread.

Gray Over a year ago

I'm not sure how to answer @OneZero. Declaring it as volatile won't work because ++ is not atomic. You could synchronize on it every time you update it or use AtomicInteger. Making it volatile isn't enough.

Mel Nicholson Over a year ago

@OneZero docs.oracle.com/javase/tutorial/essential/concurrency/… should explain a bit about what volitile is for. Not this.

Mel Nicholson Over a year ago

@OneZero a non-volitile read can get some bits for the pre-write value, and others from a post-write value, but only for types larger than a word on the underlying memory. double is the most common offender. Generally speaking, most concurrency issues are too much for volatile so look at synchronize and wait instead.

Mel Nicholson Over a year ago

@Gray In practice on anything build this millenium, probably true. I don't think the guarantee is in the language spec, though. Perhaps a more practical guarantee is that write-order is preserved, so if you have a double data and a volitile boolean ready and code that sets data first and ready = true second, it is certain that after you see ready turn to true, data will also have been set, even in a different thread. This is not guaranteed without the volatile keyword, where you can see ready true and then the value of data may not have propagated from the write thread.

|

Collectives™ on Stack Overflow

Java volatile variable doesn't behave correctly.

1 Answer 1

13 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

13 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related