在Java内存模型中，同步和易失性是如何工作的？

Question

在《有效Java》一书中：

// 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;
    }
}

后台线程不会在一秒钟后停止。因为提升，在JVM中优化，HotSpot服务器VM做。

您可以在以下主题中查看这一点：
为什么HotSpot会使用提升优化以下内容？。

优化过程如下：

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

有两种方法可以解决这个问题。

private static volatile boolean stopRequested;

volatile的函数是
-禁止提升
-它保证任何读取该字段的线程都会看到最近写入的值

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();
    }
}

上面的代码在有效Java书中是正确的，它相当于使用易失性来装饰停止请求。

private static boolean stopRequested() {
    return stopRequested;
}

如果此方法忽略了synchronized关键字，则此程序无法正常运行
我认为，当方法忽略synchronized关键字时，这种变化会导致提升<是这样吗？

Answer 1

声明易失性Java变量意味着：

这个变量的值永远不会被本地线程缓存：所有读写操作都将直接进入“主内存”；

声明同步的意思是：
所以，在易失性中只同步线程内存和主内存之间的一个变量的值，同步同步方法中线程内存和主内存之间的所有变量的值，并锁定和释放一个监视器来控制多个线程之间的所有权。

Answer 2

不是这样的。当同步方法退出时，它会自动为同一对象的同步方法的任何后续调用建立一个先发生后发生的关系。这保证了对对象状态的更改对所有线程都是可见的。至于你上面的问题，<代码>易失性和<代码>同步都保证了可见性，使其在1秒后停止。

Answer 3

为了清楚地理解为什么会发生这种情况，你需要了解更深层次的情况。（这基本上是对所谓的先发生后发生关系的解释，我希望这种语言对读者来说更不稳定）。

通常变量存在于内存中。当线程需要使用它们时，它会从内存中取出它们并将其放入缓存中，以便在需要之前尽可能快地访问它们。

使用volatile强制线程直接从RAM内存读取和写入变量。因此，当许多线程使用相同的volatile变量时，所有线程都会看到RAM内存中存在的最后一个版本，而不是缓存中可能存在的旧副本。

当一个线程进入一个synchronized块时，它需要控制一个监控变量。所有其他线程都会等待第一个线程退出synchronized块。为了确保所有线程都能看到相同的修改，同步块中使用的所有变量都直接从RAM内存读取和写入，而不是从缓存副本读取和写入。

因此，如果您试图读取变量stopRequested，而不使用synchronized方法或不使用volatile关键字，则可以读取缓存中可能存在的该变量的旧副本。

要解决这个问题，您需要确保：

• 所有线程都在使用volatile变量
• 或者所有访问这些变量的线程都在使用synchronized块

使用该方法

private static boolean stopRequested() {
   return stopRequested;
}

如果没有synchronized关键字，并且stopRequested不是volatile则意味着您可以从无效的缓存副本中读取stopRequested的值。