How synchronized and volatile work in Java memory model?

Question

In the "Effective Java" book:

// Broken! - How long would you expect this program to run?
public class StopThread {

    private static boolean stopRequested;

    public static void main(String[] args) throws InterruptedException {
        Thread backgroundThread = new Thread(new Runnable() {
            public void run() {
                int i = 0;
                while (!stopRequested)
                    i++;
            }
        });
        backgroundThread.start();

        TimeUnit.SECONDS.sleep(1);
        stopRequested = true;
    }
}

the backgroundThread will not stop after one second. Because hoisting, the optimization in JVM, HotSpot server VM does.

You can view this in the following topic:
Why HotSpot will optimize the following using hoisting?.

The optimization goes like this:

if (!done)
    while (true)
        i++;

there are two ways to fix the problem.

1. Use volatile

private static volatile boolean stopRequested;

The function of volatile is
- forbid hoisting
- it guarantees that any thread that reads the field will see the most recently written value

2. Use synchronized

public class StopThread {

    private static boolean stopRequested;

    private static synchronized void requestStop() {
        stopRequested = true;
    }

    private static synchronized boolean stopRequested() {
        return stopRequested;
    }

    public static void main(String[] args)
                throws InterruptedException {
        Thread backgroundThread = new Thread(new Runnable() {
            public void run() {
                int i = 0;
                while (!stopRequested())
                    i++;
            }
        });
        backgroundThread.start();

        TimeUnit.SECONDS.sleep(1);
        requestStop();
    }
}

The above code is right in the Effective Java book, its equivalent that use volatile to decorate the stopRequested.

private static boolean stopRequested() {
    return stopRequested;
}

If this method omit the synchronized keyword, this program isn't working well.
I think that this change cause the hoisting when the method omit the synchronized keyword.
Is that right?

Davide Lorenzo MARINO · Accepted Answer · 2016-10-08T08:18:08.030

To clearly understand why this happens you need to know something about what happens at a deeper level. (This is basically an explanation of what is called a happens-before relationship, with a language that I hope is more understable for the reader).

Normally variables are present in the RAM memory. When a thread needs to use them it take them from the RAM and put them in cache so it can access them as fast as possible until needed.

Using volatile force a thread to read and write variables directly from RAM memory. So when many thread are using the same volatile variable all them see the last version that is present in RAM memory and not a possible old copy in cache.

When a thread enter a synchronized block it needs to take control of a monitor variable. All other threads wait until the first thread exit from the synchronized block. To ensure that all thread can see the same modifications all variables used in a synchronized block are read and written directly from the RAM memory instead from a cache copy.

So if you try to read the variable stopRequested without a synchronized method or without a volatile keyword you can read a possible old copy of it that is present in the cache.

To solve this you need to be sure that:

all threads are using volatile variables
or all thread that access those variable are using a synchronized block.

Using the method

private static boolean stopRequested() {
   return stopRequested;
}

without a synchronized keyword and when stopRequested is not volatile means that you can read the value of stopRequested from a cache copy that is invalid.

Thanks, i wonder that if using `volatile` or `synchronized`, it also forbid **hoisting** ? if it not, this program will run correctly? — Edward, Oct 08 '16 at 08:29

score 0 · Answer 2 · answered Oct 08 '16 at 07:57

0

It is not . When a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads. As to your question above , both volatile and synchronized guarantee the visibility which makes it stops after 1s.

answered Oct 08 '16 at 07:57

passion

1,250
9
15

yes you is right. But i ask if synchroized is omitted in method `stopRequested`,but this keyword in method `requestStop` still exist.So executing requestStop mehtod can change the value of `stopRequested` and be seen by other thread. if the `hoisting` do not happen,i think this program is running correctly. – Edward Oct 08 '16 at 08:09
@Edward `synchroized` of `stopRequested` guarantees that every thread entered the method can see the newest variables `synchroized` blocked , it can not be omitted . Are you think of that once `synchroized` , the blocked variables changes are always visiable ? – passion Oct 08 '16 at 08:25

score 0 · Answer 3 · answered Mar 11 '19 at 04:58

Declaring a volatile Java variable means:

The value of this variable will never be cached thread-locally: all reads and writes will go straight to "main memory";

Declaring a synchronization means:
So, where volatile only synchronizes the value of one variable between the thread memory and the "main" memory, synchronized synchronizes the value of all variables between the thread memory and the "main" memory in method and locks and releases a monitor to control the ownership between multiple threads.

How synchronized and volatile work in Java memory model?

1. Use volatile

2. Use synchronized

3 Answers3