Java虚拟机：Java内存模型（JMM）

最新推荐文章于 2022-07-23 21:59:46 发布

行百里者半九九

最新推荐文章于 2022-07-23 21:59:46 发布

阅读量208

点赞数

分类专栏： Java虚拟机

本文链接：https://blog.csdn.net/qq_41969790/article/details/108214187

版权

Java虚拟机专栏收录该内容

2 篇文章 0 订阅

订阅专栏

Java内存模型

3.3 对于volatile型变量的特殊规则

Java内存模型中对volatile变量定义的特殊规则如下：

3.4 对于long和double型变量的特殊规则

3.5 Java内存模型的特征

3.6 先行发生原则

1、概述

多任务处理器在现代计算机操作系统中几乎已是一项必备的功能。在许多情况下，让计算机同时去做几件事情，不仅是因为计算机的运算能力强大了，还有一个重要原因是计算机的运算速度与它的存储和通信子系统速度的差距太大了，大量的时间都花费在磁盘IO、网络通信或者数据库访问上。如果不希望处理器大部分时间里都处于等待其他资源的状况，就必须使用一些手段去把处理器的运算能力“压榨”出来，否则就会造成很大的浪费。

除了充分利用计算机处理器的能力外。一个服务端同时对多个客户提供服务则是另一种更具体的并发应用场景。衡量一个服务性能的高低搞坏，每秒事务处理数（TPS）是最重要的指标之一，它代表着一秒内服务端平均能响应的请求总数，而TPS值与程序的并发能力又有非常密切的关系。对于计算量相同的任务，程序线程并发协调得越有条不紊，效率自然就会越高；反之，线程之间频繁阻塞甚至死锁，将会大大降低程序的并发能力。

2、硬件的效率与一致性

“让计算机并发执行若干个运算任务”与“更充分地利用计算机处理器的效能”之间的因果关系，看起来顺理成章，时间上他们之间的关系并没有想象中的那么简单，其中一个重要的复杂性来源是绝大多数的运算任务都不可能只靠处理器“计算”就能完成，处理器要与内存交互，如读取运算数据、存储运算结果等，这些I/O操作是很难消除的（无法仅靠寄存器来完成所有的运算任务）。

由于计算机的存储设备与处理器的运算速度有几个数量及的差距，所有现代计算机系统都不得不加入一层读写速度尽可能接近处理器运算速度的高速缓冲来作为内存与处理器之间的缓冲：将运算需要使用到的数据复制到缓存中，让运算能快速运行，当运算结束后再从缓存同步回内存之中，这样处理器就无须等待缓慢的内存读写了。

基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，但是也为计算机系统带来更高的复杂度，因为它引入了新问题：缓存一致性。在多处理器系统中，每个处理器都有自己的高速缓存，而它们又共享同一主内存，如下图所示。当多个处理器的运算任务涉及到同一个块主内存区域是，将有可能导致格子的缓存数据不一致性的问题，需要各个处理器访问缓存时遵循一些协议，在读写时根据这些来进行操作，这类协议有MSI、MESI、MOSI、Synape、Firefly及Dragon Protocol等。“内存模型”可以理解为在特定的操作协议下，对特定的内存或高速缓存进行读写访问的过程抽象，不同架构的物理机器可以拥有不一样的内存模型，而Java虚拟机也有自己的内存模型，并且这里介绍的内存访问操作与硬件的缓存访问操作具有很高的可比性。

除了增加高速缓存之外，为了使得处理器内部的运算单元能尽量被充分利用，处理器可能会对输入代码进行乱序执行优化，处理器会在计算之后将乱序执行的结果重组，保证该结果与顺序执行的结果是一致性的，但并不保证程序中各个语句计算的先后顺序与输入代码中的顺序一致。因此，如果存在一个计算任务依赖于另外一个计算任务的中间结果，那么其顺序性并不能靠代码的先后顺序来保证。与处理器的乱序执行优化类似，Java虚拟机的即时编译器中也有类似的指令重排序优化。

3、Java内存模型

Java虚拟机规范中试图定义一种Java内存模型来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。

3.1 主内存与工作内存

Java内存模型的主要目标是定义程序中各个变量的访问规则，即在虚拟机中将变量存储到内存和从内存中取出变量这样的底层细节。此处的变量与Java编程中所说的变量有所区别，它包括了实例字段、静态字段和构成数组对象的元素，但不包括局部变量与方法参数，因为后者是线程私有的，不会被共享，自然就不会存在竞争问题。为了获得较好的执行效能，Java内存模型并没有限制执行引擎使用处理器的特定寄存器或缓存来和主内存进行交互，也没有限制即时编译器进行调整代码执行顺序这类优化措施。

Java内存模型规定了所有的变量都存储在主内存中，每条线程还有自己的工作内存，主要定义和理解如下：

（1）主内存：Java虚拟机规定所有的变量(不是程序中的变量)都必须在主内存中产生，为了方便理解，可以认为是堆区。可以与前面说的物理机的主内存相比，只不过物理机的主内存是整个机器的内存，而虚拟机的主内存是虚拟机内存中的一部分。

（2）工作内存：Java虚拟机中每个线程都有自己的工作内存，该内存是线程私有的为了方便理解，可以认为是虚拟机栈。可以与前面说的高速缓存相比。线程的工作内存保存了线程需要的变量在主内存中的副本。

虚拟机规定，线程对主内存变量的修改必须在线程的工作内存中进行，不能直接读写主内存中的变量。不同的线程之间也不能相互访问对方的工作内存。如果线程之间需要传递变量的值，必须通过主内存来作为中介进行传递。

需要注意的是：这里所讲的主内存、工作内存与本书第2章所讲的Java内存区域中的Java堆、栈、方法区等并不是同一个层次的内存划分，这两者基本上是没有关系的，如果两者一定要勉强对应起来，那从变量、主内存、工作内存的定义来看，主内存主要对应于Java堆中的对象实例数据部分，而工作内存则对应于虚拟机栈中的部分区域。从更低层次上来说，主内存就直接对应于物理硬件的内存，而为了获取更好的运行速度，虚拟机（甚至是硬件系统本身的优化措施）可能会让工作内存优先存储于寄存器和高速缓存中，因为程序运行时主要访问读写的是工作内存。

3.2 内存间交互操作

主内存和工作内存之间具体的交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存之类的实现细节。Java内存模型中定义了以下8种操作来完成，虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的（对于double和龙类型的变量来说，load/store/read/write操作在某些平台上允许有例外）。

（1）lock(锁定):作用于主内存的变量，一个变量在同一时间只能一个线程锁定，该操作表示这条线成独占这个变量。

（2）unlock(解锁):作用于主内存的变量，表示这个变量的状态由处于锁定状态被释放，这样其他线程才能对该变量进行锁定。

（3）read(读取):作用于主内存变量，表示把一个主内存变量的值传输到线程的工作内存，以便随后的load操作使用。

（4）load(载入):作用于线程的工作内存的变量，表示把read操作从主内存中读取的变量的值放到工作内存的变量副本中(副本是相对于主内存的变量而言的).

（5）use(使用):作用于线程的工作内存中的变量，表示把工作内存中的一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时就会执行该操作。

（6）assign(赋值):作用于线程的工作内存的变量，表示把执行引擎返回的结果赋值给工作内存中的变量，每当虚拟机遇到一个给变量赋值的字节码指令时就会执行该操作。

（7）store(存储):作用于线程的工作内存中的变量，把工作内存中的一个变量的值传递给主内存，以便随后的write操作使用。

（8）write(写入):作用于主内存的变量，把store操作从工作内存中得到的变量的值放入主内存的变量中。

如果要把一个变量从主内存负载到工作内存，那么就要顺序地执行read和load操作，如果要把遍历从工作内存同步回主内存，就要顺序地执行store和write操作。Java内存只要求上述的两个操作必须按顺序执行，而没有保证是连续执行。Java内存模型还规定了在执行上述8种基本操作时必须满足如下规则：

（1）不允许read和load、store和write操作之一单独出现，也就是不允许从主内存读取了变量的值但是工作内存不接收的情况，或者不允许从工作内存将变量的值回写到主内存但是主内存不接收的情况。

（2）不允许一个线程丢弃最近的assign操作，也就是不允许线程在自己的工作线程中修改了变量的值却不同步/回写到主内存。

（3）不允许一个线程回写没有修改的变量到主内存，也就是如果线程工作内存中变量没有发生过任何assign操作，是不允许将该变量的值回写到主内存。

（4）变量只能在主内存中产生，不允许在工作内存中直接使用一个未被初始化的变量，也就是没有执行load或者assign操作。也就是说在执行use、store之前必须对相同的变量执行了load、assign操作。

（5）一个变量在同一时刻只能被一个线程对其进行lock操作，也就是说一个线程一旦对一个变量加锁后，在该线程没有释放掉锁之前，其他线程是不能对其加锁的，但是同一个线程对一个变量加锁后，可以继续加锁，同时在释放锁的时候释放锁次数必须和加锁次数相同。

（6）对变量执行lock操作，就会清空工作空间该变量的值，执行引擎使用这个变量之前，需要重新load或者assign操作初始化变量的值。

（7）不允许对没有lock的变量执行unlock操作，如果一个变量没有被lock操作，那也不能对其执行unlock操作，当然一个线程也不能对被其他线程lock的变量执行unlock操作。

（8）对一个变量执行unlock之前，必须先把变量同步回主内存中，也就是执行store和write操作。

当然，最重要的还是如开始所说，这8个动作必须是原子的，不可分割的。针对volatile修饰的变量，会有一些特殊规定。

3.3 对于volatile型变量的特殊规则

当一个变量定义为volatile之后，它将具备两种特性：

（1）可见性

这里的可见性是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的。而普通变量不能做到这一点，普通变量的值在线程间床底均需要通过主内存来完成。需要注意的是：Java里面的运算并非原子操作，导致vilatile变量的运算在并发下一样是不安全的。下面示例为说明volatile关键字在并发情况下不是线程安全的，因为自增操作不是原子性的：

public class VolatileTest {
    public static volatile int race = 0;
    public static void increase() {
        race++;
    }

    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i= 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable(){
                @Override
                public void run() {
                    for (int j = 0; j < 10000; j++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }

        //下面这里如果设置成>1，会一直得不到输出，程序一直在此循环，最后发现activeCount的值由20减少为2；因此设置成>2.
        while (Thread.activeCount() > 2) {
            System.out.println(Thread.activeCount());
            Thread.yield();
        }
        System.out.println(race);
    }
}

//每次输出结果都小于200000，且每次结果都不一样。

（2）禁止指令重排序优化

　一般情况下，在执行程序时为了提高性能，编译器和处理器经常会对指令进行重排序。重排序分成三种类型：

编译器优化的重排序。编译器在不改变单线程程序语义放入前提下，可以重新安排语句的执行顺序。
指令级并行的重排序。现代处理器采用了指令级并行技术来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序。
内存系统的重排序。由于处理器使用缓存和读写缓冲区，这使得加载和存储操作看上去可能是在乱序执行。

从Java源代码到最终实际执行的指令序列，会经过下面三种重排序：

为了保证内存的可见性，Java编译器在生成指令序列的适当位置会插入内存屏障指令来禁止特定类型的处理器重排序。Java内存模型把内存屏障分为LoadLoad、LoadStore、StoreLoad和StoreStore四种：

普通的变量仅仅会保证在该方法的执行过程中所有依赖赋值结果的地方都能获取到正确的结果，而不能保证变量赋值操作的顺序与程序代码中的执行顺序一致。因为在一个线程的方法执行过程中无法感知到这边，这也就是Java内存模型中描述的所谓的“线程内表现为串行的语义”。Java中volatile禁止指令重排序是通过插入内存屏障来保证的，指令重排序时，不能把内存屏障后面的指令重排序到到内存屏障之前的位置。

Java内存模型中对volatile变量定义的特殊规则如下：

假定T表示一个线程，V和W分别表示两个volatile修饰的变量，那么在进行read、load、use、assign、store和write操作的时候需要满足如下规则：

（1）只有当线程T对变量V执行的前一个动作是load，线程T对变量V才能执行use动作；同时只有当线程T对变量V执行的后一个动作是use的时候线程T对变量V才能执行load操作。所以，线程T对变量V的use动作和线程T对变量V的read、load动作相关联，必须是连续一起出现。也就是在线程T的工作内存中，每次使用变量V之前必须从主内存去重新获取最新的值，用于保证线程T能看得见其他线程对变量V的最新的修改后的值。

（2）只有当线程T对变量V执行的前一个动作是assign的时候，线程T对变量V才能执行store动作；同时只有当线程T对变量V执行的后一个动作是store的时候，线程T对变量V才能执行assign动作。所以，线程T对变量V的assign操作和线程T对变量V的store、write动作相关联，必须一起连续出现。也即是在线程T的工作内存中，每次修改变量V之后必须立刻同步回主内存，用于保证线程T对变量V的修改能立刻被其他线程看到。

（3）假定动作A是线程T对变量V实施的use或assign动作，动作F是和动作A相关联的load或store动作，动作P是和动作F相对应的对变量V的read或write动作；类似的，假定动作B是线程T对变量W实施的use或assign动作，动作G是和动作B相关联的load或store动作，动作Q是和动作G相对应的对变量W的read或write动作。如果动作A先于B，那么P先于Q。也就是说在同一个线程内部，被volatile修饰的变量不会被指令重排序，保证代码的执行顺序和程序的顺序相同。

3.4 对于long和double型变量的特殊规则

Java内存模型要求对主内存和工作内存交换的八个动作是原子的，正如前面所述，对long和double有一些特殊规则。八个动作中lock、unlock、read、load、use、assign、store、write对于32位的基本数据类型都是原子操作；但对于long和double这两个64位的数据，java虚拟机规范对java内存模型的规定中特别定义了一条相对宽松的规则：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行，也就是允许虚拟机不保证对64位数据的read、load、store和write这4个动作的操作是原子的。这也就是我们常说的long和double的非原子性协定(Nonautomic Treatment of double and long Variables)。

3.5 Java内存模型的特征

Java内存模型是围绕着在并发过程中如何处理原子性、可见性、有序性这3个特征来建立的：

（1）原子性

由Java内存模型来直接保证原子性的变量操作包括read、load、use、assign、store、write这6个动作，虽然存在long和double的特例，但基本可以忽律不计，目前虚拟机基本都对其实现了原子性。如果需要更大范围的控制，lock和unlock也可以满足需求。lock和unlock虽然没有被虚拟机直接开给用户使用，但是提供了字节码层次的指令monitorenter和monitorexit对应这两个操作，对应到java代码就是synchronized关键字，因此在synchronized块之间的代码都具有原子性。

（2）可见性

可见性是指一个线程修改了一个变量的值后，其他线程立即可以感知到这个值的修改。正如前面所说，volatile类型的变量在修改后会立即同步给主内存，在使用的时候会从主内存重新读取，是依赖主内存为中介来保证多线程下变量对其他线程的可见性的。除了volatile，synchronized和final也可以实现可见性。synchronized关键字是通过unlock之前必须把变量同步回主内存来实现的，final则是在初始化后就不会更改，所以只要在初始化过程中没有把this指针传递出去也能保证对其他线程的可见性。

（3）有序性

有序性从不同的角度来看是不同的。单纯单线程来看都是有序的，但到了多线程就会跟我们预想的不一样。可以这么说：如果在本线程内部观察，所有操作都是有序的；如果在一个线程中观察另一个线程，所有的操作都是无序的。前半句说的就是“线程内表现为串行的语义”，后半句值得是“指令重排序”现象和主内存与工作内存之间同步存在延迟的现象。保证有序性的关键字有volatile和synchronized，volatile禁止了指令重排序，而synchronized则由“一个变量在同一时刻只能被一个线程对其进行lock操作”来保证。

总体来看，synchronized对三种特性都有支持，虽然简单，但是如果无控制的滥用对性能就会产生较大影响。

3.6 先行发生原则

如果Java内存模型中所有的有序性都要依靠volatile和synchronized来实现，那是不是非常繁琐。Java语言中有一个“先行发生原则”，是判断数据是否存在竞争、线程是否安全的主要依据。

什么是先行发生原则？

先行发生原则是Java内存模型中定义的两个操作之间的偏序关系。比如说操作A先行发生于操作B，那么在B操作发生之前，A操作产生的“影响”都会被操作B感知到。这里的影响是指修改了内存中的共享变量、发送了消息、调用了方法等。个人觉得更直白一些就是有可能对操作B的结果有影响的都会被B感知到，对B操作的结果没有影响的是否感知到没有太大关系。

Java内存模型下一些“天然的”先行发生关系？

（1）程序次序原则

在一个线程内部，按照代码的顺序，书写在前面的先行发生与后边的。或者更准确的说是在控制流顺序前面的先行发生与控制流后面的，而不是代码顺序，因为会有分支、跳转、循环等。

（2）管程锁定规则

一个unlock操作先行发生于后面对同一个锁的lock操作。这里必须注意的是对同一个锁，后面是指时间上的后面。

（3）volatile变量规则

对一个volatile变量的写操作先行发生于后面对这个变量的读操作，这里的后面是指时间上的先后顺序。

（4）线程启动规则

Thread对象的start()方法先行发生与该线程的每个动作。当然如果你错误的使用了线程，创建线程后没有执行start方法，而是执行run方法，那此句话是不成立的，但是如果这样其实也不是线程了

（5）线程终止规则

线程中的所有操作都先行发生与对此线程的终止检测，可以通过Thread.join()和Thread.isAlive()的返回值等手段检测线程是否已经终止执行。

（6）线程中断规则

对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted()方法检测到是否有中断发生。

（7）对象终结规则

一个对象的初始化完成先行发生于他的finalize方法的执行，也就是初始化方法先行发生于finalize方法。

（8）传递性

如果操作A先行发生于操作B，操作B先行发生于操作C，那么操作A先行发生于操作C。

上述这些先行发生关系无须任何同步器协助就已经存在，可以在编码中直接使用。如果两个操作之间的关系不在此列，并且无法从上述规则推导出来的话，他们就没有顺序性保障，虚拟机可以对他们随意地进行重排序。

一个简单示例如下：

private int value = 0;
public void setValue(int value) {
  this.value = value;
}
public int getValue() {
  return this.value;
}

如果有两个线程A和B，A先调用setValue方法，然后B调用getValue方法，那么B线程执行方法返回的结果是什么？

我们去对照先行发生原则一个一个对比。首先是程序次序规则，这里是多线程，不在一个线程中，不适用；然后是管程锁定规则，这里没有synchronized，自然不会发生lock和unlock，不适用；后面对于线程启动规则、线程终止规则、线程中断规则也不适用，这里与对象终结规则、传递性规则也没有关系。所以说B返回的结果是不确定的，也就是说在多线程环境下该操作不是线程安全的。

如何修改呢，一个是对get/set方法加入synchronized 关键字，可以使用管程锁定规则；要么对value加volatile修饰，可以使用volatile变量规则。

通过上面的例子可知，一个操作时间上先发生并不代表这个操作先行发生，那么一个操作先行发生是不是代表这个操作在时间上先发生？也不是，如下面的例子：

int i = 2;
int j = 1;

在同一个线程内，对i的赋值先行发生于对j赋值的操作，但是代码重排序优化，也有可能是j的赋值先发生，我们无法感知到这一变化。

需要注意的是：时间先后顺序与先行发生原则之间基本没有太大关系。我们衡量并发安全的问题的时候不要受到时间先后顺序的干扰，一切以先行发生原则为准。

声明：本文部分内容整理来源于网络，仅做个人学习使用！侵删~

本文部分内容参考链接：

（1）《深入理解Java虚拟机》（第二版）

（2）https://www.cnblogs.com/nexiyi/p/java_memory_model_and_thread.html

（3）https://www.jianshu.com/p/15106e9c4bf3

行百里者半九九

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Java虚拟机：Java内存模型（JMM）

1、概述多任务处理器在现代计算机操作系统中几乎已是一项必备的功能。在许多情况下，让计算机同时去做几件事情，不仅是因为计算机的运算能力强大了，还有一个重要原因是计算机的运算速度与它的存储和通信子系统速度的差距太大了，大量的时间都花费在磁盘IO、网络通信或者数据库访问上。如果不希望处理器大部分时间里都处于等待其他资源的状况，就必须使用一些手段去把处理器的运算能力“压榨”出来，否则就会造成很大的浪费。除了充分利用计算机处理器的能力外。一个服务端同时对多个客户提供服务则是另一种更具体的并发应用场景。衡量一个
复制链接

扫一扫