设计模式3：单例模式：JMM与volatile和synchronized的关系

JMM简介

Java 内存模型指定 Java 虚拟机如何使用计算机内存 (RAM)。 Java 虚拟机是整个计算机的模型，因此该模型自然包括内存模型 - 又称为 Java 内存模型。

如果您想设计行为正确的并发程序，那么了解 Java 内存模型非常重要。 Java内存模型指定不同线程如何以及何时可以看到其他线程写入共享变量的值，以及如何在必要时同步对共享变量的访问。

原来的Java内存模型是不够的，所以在Java 1.5中对Java内存模型进行了修改。 这个版本的 Java 内存模型至今仍在 Java 中使用（Java 14+）。

Java 内部内存模型(The Internal Java Memory Model)

JVM 内部使用的 Java 内存模型在线程栈和堆之间划分内存。 下图从逻辑角度说明了Java内存模型：

Java虚拟机中运行的每个线程都有自己的线程栈。 线程栈包含有关线程调用了哪些方法来到达当前执行点的信息。 我将其称为“调用栈”(call stack)。 当线程执行其代码时，调用栈会发生变化。

线程栈还包含正在执行的每个方法的所有局部变量（调用栈上的所有方法）。 线程只能访问它自己的线程栈。 线程创建的局部变量对于除创建它的线程之外的所有其他线程都是不可见的。 即使两个线程正在执行完全相同的代码，这两个线程仍然会在各自的线程栈中创建该代码的局部变量。 因此，每个线程都有自己的每个局部变量的版本。

所有基本类型的局部变量（boolean、byte、short、char、int、long、float、double）都完全存储在线程栈上，因此对其他线程不可见。 一个线程可以将原始变量的副本传递给另一个线程，但它不能共享原始局部变量本身。

堆包含在 Java 应用程序中创建的所有对象，无论哪个线程创建了该对象。 这包括基本类型的对象版本（例如 Byte、Integer、Long 等）。 无论一个对象是被创建并分配给局部变量，还是作为另一个对象的成员变量创建，该对象仍然存储在堆上。

下面的图表说明了存储在线程栈上的调用堆栈和局部变量以及存储在堆上的对象：

Java 内存模型显示局部变量和对象在内存中的存储位置。
局部变量可能是原始类型，在这种情况下，它完全保存在线程栈上。

局部变量也可以是对对象的引用。 在这种情况下，引用（局部变量）存储在线程栈上，但对象本身存储在堆上。

对象可以包含方法，并且这些方法可以包含局部变量。 这些局部变量也存储在线程栈上，即使方法所属的对象存储在堆上。

对象的成员变量与对象本身一起存储在堆上。 当成员变量是基本类型以及对对象的引用时都是如此。

静态类变量也与类定义一起存储在堆上。

堆上的对象可以被所有引用该对象的线程访问。 当线程可以访问对象时，它也可以访问该对象的成员变量。 如果两个线程同时调用同一个对象的方法，它们都可以访问该对象的成员变量，但每个线程都有自己的局部变量副本。

这是说明上述几点的图表：

Java 内存模型显示从局部变量到对象以及从对象到其他对象的引用。
两个线程有一组局部变量。 局部变量之一（局部变量 2）指向堆上的共享对象（对象 3）。 这两个线程各自对同一对象有不同的引用。 它们的引用是局部变量，因此存储在每个线程的线程栈中（每个线程）。 不过，这两个不同的引用指向堆上的同一个对象。

请注意共享对象（对象 3）如何将对象 2 和对象 4 作为成员变量进行引用（如从对象 3 到对象 2 和对象 4 的箭头所示）。 通过对象 3 中的这些成员变量引用，两个线程可以访问对象 2 和对象 4。

该图还显示了一个指向堆上两个不同对象的局部变量。 在本例中，引用指向两个不同的对象（对象 1 和对象 5），而不是同一个对象。 理论上，如果两个线程都引用了对象 1 和对象 5，则两个线程都可以访问这两个对象。 但在上图中，每个线程仅具有对两个对象之一的引用。

那么，什么样的 Java 代码会导致上面的内存图呢？ 好吧，代码就这么简单，如下代码：

public class MyRunnable implements Runnable() {
    
    

    public void run() {
    
    
        methodOne();
    }

    public void methodOne() {
    
    
        int localVariable1 = 45;

        MySharedObject localVariable2 = MySharedObject.sharedInstance;

        //... do more with local variables.

        methodTwo();
    }

    public void methodTwo() {
    
    
        Integer localVariable1 = new Integer(99);

        //... do more with local variable.
    }
}

public class MySharedObject {
    
    

    //指向 MySharedObject 单例的静态变量
    public static final MySharedObject sharedInstance = new MySharedObject();


    //指向堆上两个对象的成员变量

    public Integer object2 = new Integer(22);
    public Integer object4 = new Integer(44);

    public long member1 = 12345;
    public long member2 = 67890;
}

如果两个线程正在执行 run() 方法，则结果将是前面显示的图表。 run() 方法调用 methodOne()，methodOne() 调用 methodTwo()。

methodOne() 声明一个原始局部变量（int 类型的 localVariable1）和一个对象引用的局部变量（localVariable2）。

每个执行 methodOne() 的线程都会在各自的线程栈上创建自己的 localVariable1 和 localVariable2 副本。 localVariable1 变量将彼此完全分离，仅存在于每个线程的线程栈上。 一个线程无法看到另一个线程对其 localVariable1 副本所做的更改。

每个执行 methodOne() 的线程也将创建自己的 localVariable2 副本。 然而，localVariable2 的两个不同副本最终都指向堆上的同一个对象。 该代码将 localVariable2 设置为指向静态变量引用的对象。 静态变量只有一份副本，并且该副本存储在堆上。 因此，localVariable2 的两个副本最终都指向静态变量所指向的 MySharedObject 的同一个实例。 MySharedObject 实例也存储在堆上。 它对应于上图中的对象3。

请注意 MySharedObject 类也包含两个成员变量。 成员变量本身与对象一起存储在堆上。 这两个成员变量指向另外两个 Integer 对象。 这些 Integer 对象对应于上图中的对象 2 和对象 4。

另请注意 methodTwo() 如何创建名为 localVariable1 的局部变量。 该局部变量是对 Integer 对象的对象引用。 该方法将 localVariable1 引用设置为指向新的 Integer 实例。 localVariable1 引用将存储在每个执行 methodTwo() 的线程的一份副本中。 实例化的两个 Integer 对象将存储在堆上，但由于该方法每次执行时都会创建一个新的 Integer 对象，因此执行该方法的两个线程将创建单独的 Integer 实例。 methodTwo() 内创建的 Integer 对象对应于上图中的对象 1 和对象 5。

还要注意 MySharedObject 类中 long 类型的两个成员变量，它是原始类型。 由于这些变量是成员变量，因此它们仍然与对象一起存储在堆上。 只有局部变量存储在线程栈中。

硬件内存架构(Hardware Memory Architecture)

现代硬件内存架构与内部 Java 内存模型有些不同。 了解硬件内存架构以及 Java 内存模型如何与其配合也很重要。 本节介绍常见的硬件内存架构，后面的部分将介绍 Java 内存模型如何与其配合使用。

这是现代计算机硬件架构的简化图：

现代计算机通常有 2 个或更多 CPU。 其中一些 CPU 也可能具有多个内核。 关键是，在一台具有 2 个或更多 CPU 的现代计算机上，可以有多个线程同时运行。 每个 CPU 都能够在任何给定时间运行一个线程。 这意味着，如果您的 Java 应用程序是多线程的，则每个 CPU 一个线程可能会在您的 Java 应用程序中同时运行。

每个 CPU 都包含一组寄存器，这些寄存器本质上是 CPU 内存。 CPU 在这些寄存器上执行操作的速度比在主内存中的变量上执行操作的速度快得多。 这是因为 CPU 访问这些寄存器的速度比访问主内存的速度快得多。

每个CPU还可以具有CPU高速缓存存储器层。 事实上，大多数现代 CPU 都有一定大小的高速缓存层。 CPU 访问其高速缓存的速度比主内存快得多，但通常不如访问其内部寄存器的速度快。 因此，CPU 高速缓存的速度介于内部寄存器和主存储器之间。 某些 CPU 可能有多个缓存层（1 级和 2 级），但这对于理解 Java 内存模型如何与内存交互并不那么重要。 重要的是要知道 CPU 可以有某种缓存层。

计算机还包含主存储区域（RAM）。 所有CPU都可以访问主存。 主存储器区域通常比 CPU 的高速缓冲存储器大得多。

通常，当 CPU 需要访问主存时，它会将主存的一部分读入 CPU 缓存。 它甚至可以将部分缓存读入其内部寄存器，然后对其执行操作。 当CPU需要将结果写回到主存时，它会将内部寄存器中的值刷新到高速缓冲存储器，并在某个时刻将值刷新回主存。

当CPU需要在高速缓冲存储器中存储其他内容时，存储在高速缓冲存储器中的值通常被刷新回主存储器。 CPU 缓存可以一次将数据写入其内存的一部分，并一次刷新其内存的一部分。 每次更新时不必读取/写入完整缓存。 通常，缓存在称为“缓存行”的较小内存块中更新。 一个或多个高速缓存行可被读入高速缓冲存储器，并且一个或多个高速缓存行可被再次刷新回主存储器。

弥合 Java 内存模型和硬件内存架构之间的差距(Bridging The Gap Between The Java Memory Model And The Hardware Memory Architecture)

正如已经提到的，Java 内存模型和硬件内存架构是不同的。 硬件内存架构不区分线程栈和堆。 在硬件上，线程栈和堆都位于主存中。 部分线程栈和堆有时可能存在于 CPU 缓存和内部 CPU 寄存器中。 下图对此进行了说明：

线程栈和堆在CPU内部寄存器、CPU缓存和主存之间的划分:
当对象和变量可以存储在计算机中的各种不同的存储区域中时，可能会出现某些问题。 两个主要问题是：

• 线程更新（写入）共享变量的可见性。
• 读取、检查和写入共享变量时的竞争条件。

这两个问题都将在以下部分中进行解释。

1.共享对象的可见性

如果两个或多个线程共享一个对象，而没有正确使用 易失性声明（volatile declarations ）或同步（synchronization），则一个线程对共享对象所做的更新可能对其他线程不可见。

想象一下共享对象最初存储在主内存中。 然后，在 CPU 1 上运行的线程将共享对象读取到其 CPU 缓存中。 在那里它对共享对象进行更改。 只要 CPU 缓存尚未刷新回主内存，共享对象的更改版本对于其他 CPU 上运行的线程来说是不可见的。 这样，每个线程最终可能会得到自己的共享对象副本，每个副本位于不同的 CPU 缓存中。

下图说明了所描绘的情况。 运行在左侧 CPU 上的一个线程将共享对象复制到其 CPU 缓存中，并将其 count 变量更改为 2。这一更改对于运行在右侧 CPU 上的其他线程不可见，因为对 count 的更新尚未刷新回主存。

为了解决这个问题可以使用Java的 volatile 关键字。 volatile 关键字可以确保直接从主存读取给定变量，并在更新时始终写回主存。

2.竞争条件

如果两个或多个线程共享一个对象，并且多个线程更新该共享对象中的变量，则可能会出现竞争条件。

想象一下，如果线程 A 将共享对象的变量计数读取到其 CPU 缓存中。 也想象一下，线程 B 执行相同的操作，但进入不同的 CPU 缓存。 现在线程 A 将计数加一，线程 B 也执行同样的操作。 现在 var1 已增加两次，每个 CPU 缓存中一次。

如果这些增量是按顺序执行的，则变量计数将增加两次，并将原始值 + 2 写回主存储器。

然而，这两个增量是同时进行的，没有适当的同步。 无论线程 A 和 B 中哪一个将其更新版本的 count 写回主内存，尽管有两次增量，更新后的值只会比原始值高 1。

该图说明了如上所述的竞争条件问题的发生：

为了解决这个问题，你可以使用Java同步块(Java synchronized block)。 同步块保证在任何给定时间只有一个线程可以进入代码的给定关键部分。 同步块还保证在同步块内访问的所有变量都将从主内存中读入，并且当线程退出同步块时，所有更新的变量将再次刷新回主内存，无论该变量是否被声明为 volatile 或 没有声明。