线程何时从主内存而不是工作内存中读取非易失性变量？

Question

public class Main {

public static void main(String[] args) throws InterruptedException {
    Worker w = new Worker();
    w.start();

    sleepQuietly(1000);

    w.alive = false;
    w.join();
}

static class Worker extends Thread {
    boolean alive = true;

    @Override
    public void run() {
        while (alive) {
        }
    }
}

static void sleepQuietly(long millis) {
    try {
        Thread.sleep(millis);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

If I run the main method above, the main thread won't stop.But if I run the main method below, the main method will stop.

public class Main {

public static void main(String[] args) throws InterruptedException {
    Worker w = new Worker();
    w.start();

    sleepQuietly(1000);

    w.alive = false;
    w.join();
}

static class Worker extends Thread {
    boolean alive = true;

    @Override
    public void run() {
        while (alive) {
            sleepQuietly(1); 
        }
    }
}

static void sleepQuietly(long millis) {
    try {
        Thread.sleep(millis);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}
}

"The memory model guarantees that, given the eventual occurrence of the above operations, a particular update to a particular field made by one thread will eventually be visible to another. But eventually can be an arbitrarily long time. Long stretches of code in threads that use no synchronization can be hopelessly out of synch with other threads with respect to values of fields. In particular, it is always wrong to write loops waiting for values written by other threads unless the fields are volatile or accessed via synchronization"

I read above in http://gee.cs.oswego.edu/dl/cpj/jmm.html , and here is my question: 1. In the first example, why worker thread can't see the value updated by main thread as the JMM guarantees that a particular update to a particular field made by one thread will eventually be visible to another

2. Why does Thread.sleep() makes difference?

Answer 1

JMM guarantees that a particular update to a particular field made by one thread will eventually be visible to another

It guarantees (eventual) visibility only under certain conditions. The link you are referring to explicitly says that. A write to a non-volatile field is not among such conditions.

Why does Thread.sleep() makes difference?

Thread.sleep() is a native method that is not inlined by JIT. Calling this method breaks loop invariant hosting optimizations, so that object field is re-read each iteration. However, this behavior is an implementation detail of the particular JVM. It is not guaranteed that the program will behave the same way on other versions of JVM. Moreover, JLS explicitly warns that neither Thread.sleep nor Thread.yield have any synchronization semantics.

Answer 2

Take a look at: https://help.semmle.com/wiki/display/JAVA/Spin+on+field

class Spin {
    public boolean done = false;

    public void spin() {
        while(!done){
        }
    }
}


class Spin { // optimized
    public boolean done = false;

    public void spin() {
        boolean cond = done;
        while(!cond){
        }
    }
}

The method repeats the while-loop until the value of the field done is set by another thread. However, the compiler could optimize the code as shown in the second code snippet, because the field done is not marked as volatile and there are no statements in the body of the loop that could change the value of done. The optimized version of spin loops forever, even when another thread would set done to true.