JVM(七).Java内存模型与线程

最新推荐文章于 2022-03-09 19:58:26 发布

C0oOder

最新推荐文章于 2022-03-09 19:58:26 发布

阅读量489

点赞数

分类专栏： JVM 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/weixin_44244088/article/details/123058713

版权

JVM 专栏收录该内容

8 篇文章 1 订阅

订阅专栏

JVM(七).Java内存模型与线程

1.概述

现代计算机操作系统都是多任务处理，CPU 速度相对于IO ，网络，数据库快的不是一个数量级，也就是说处理器在很多地方都是在等待其他资源处理完成后才工作，所以必须是要充分利用号CPU 资源，尽可能的把处理器的性能压榨出来；

2.硬件的效率与一致性

由于计算机的存储设备与处理器的运算速度有着几个数量级的差距，不得不加入一层或多层读写速度尽可能接近处理器运算速度的高速缓存来作为内存与处理器之间的缓冲：将运算需要使用的数据复制到缓存中，让运算能快速进行，当运算结束后再从缓存同步回内存之中；

新的问题：缓存一致性（Cache Coherence），特别是多核系统；为此出现的协议有议有MSI、MESI（Illinois Protocol）、MOSI、 Synapse、Firefly及Dragon Protocol等内存一致性协议。此外，处理器可能会对输入代码进行乱序执行（Out-Of-Order Execution）优化，Java虚拟机的即时编译器中也有指令重排序 （Instruction Reorder）优化；

在这里插入图片描述

3. Java内存模型

Java内存模型（Java Memory Model，JMM）来屏蔽各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果；

3.1 主内存与工作内存

Java内存模型，如何定义变量，变量的访问规则，内存角度就是变量值存储到内存和在内存中取出数据的实现；Java内存模型并没有限制执行引擎使用处理器的特定寄存器或缓存来和主内存进行交互，也没有限制即时编译器是否要进行调整代码执行顺序这类优化措施

Java内存模型所有变量存储在主内存中，每个线程有自己的工作内存；

线程的工作内存中保存了被该线程使用的变量的主内存副本，线程对变量的所有操作都必须在工作内存中进行，而不能直接读写主内存中的数。

在这里插入图片描述

从更基础的层次上说，主内存直接对应于物理硬件的内存，而为了获取更好的运行速度，虚拟机（或者是硬件、操作系统本身的优化措施）可能会让工作内存优先存储于寄存器和高速缓存中，因为程序运行时主要访问的是工作内存。

3.2 内存间交互操作

Java内存模型中定义了以下8种操作来完成变量的存储和读取；

表格	含义
lock	作用于主内存的变量，它把一个变量标识为一条线程独占的状态
unlock	作用于主内存的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定
read	作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便随后的load动作使用
load	作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中
use	作用于工作内存的变量，它把工作内存中一个变量的值传递给执行引擎，每当拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作
assign	作用于工作内存的变量，它把一个从执行引擎接收的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作
store	作用于工作内存的变量，它把工作内存中一个变量的值传送到主内存中，以便随后的write操作使用
write	作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中

在这里插入图片描述

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

Java内存模型为volatile专门定义了一些特殊的访问规则

第一项是保证此变量对所有线程的可见性，这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以立即得知的；

注意：可见不是线程安全，只是说你在这个线程里面修改了，其他线程就是可以得到你修改后的值；但是不具备原子性；

第二项volatile变量的语义是禁止指令重排序优化，虚拟机执行字节码优化的时候可能会打乱原有的执行顺序；

public class Singleton {
        private volatile static Singleton instance;

        public static Singleton getInstance() {
            if (instance == null) {//先判断 减少加锁粒度
                synchronized (Singleton.class)  {  //加锁判断  当初始化的时候只有一个可以进入 执行初始化
                    if (instance == null) {  // 两个线程A,B 一起等锁，第一个A 完成了，第二个B 进来的时候也要等锁，就需要在判断一下
                        instance = new Singleton(); //A如果完成了，是因为指令重排序，B 线程如果在 第一个if判断了非空就直接返回了一个不健全的对象了，所以需要禁止重排序
                    }
                }
            }
            return instance;
        }

        public static void main(String[] args) {
            Singleton.getInstance();
        }
    }

即时编译汇编代码

0x01a3de0f: mov $0x3375cdb0,%esi ;...beb0cd75 33 ;
						{oop('Singleton')} 
0x01a3de14: mov %eax,0x150(%esi) ;...89865001 0000  //变量的赋值：创建的对象赋值给变量
0x01a3de1a: shr $0x9,%esi ;...c1ee09 
0x01a3de1d: movb $0x0,0x1104800(%esi) ;...c6860048 100100 
0x01a3de24: lock addl $0x0,(%esp) ;...f0830424 00 ;	//内存屏障//lock 本处理器的缓存写入了内存,其他核心缓存无效化，等于前面的一次store和write (可见性)
			*putstatic instance ; - Singleton::getInstance@24

于有volatile修饰的变量：指重排序时不能把后面的指令重排序到内存屏障之前的位置，初始化的操作无法越过内存屏障 保证单例对象是个正常发挥的对象

volatile变量读操作的性能消耗与普通变量没有什么差别，写操作则可能会慢，需要在本地代码中插入许多内存屏障指令来保证处理器不发生乱序执行；

注：

线程T对变量 V的use动作可以认为是和线程T对变量V的load、read动作相关联的，必须连续且一起出现；每次使用V前都必须先从主内存刷新最新的值；
线程 T对变量V的assign动作可以认为是和线程T对变量V的store、write动作相关联的，必须连续且一起出现；每次修改V后都必须立刻同步回主内存中，用于保证其他线程可以看到自己对变量V所做的修改

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

允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进行；两次非原子性就带来了->某些线程可能会读取到一个既不是原值，也不是其他线程修改值的代表了“半个变量”的数值

3.5 原子性、可见性与有序性

1. 原子性

由Java内存模型来直接保证的原子性变量操作包括read、load、assign、use、store和write这六个；

大范围的原子性有synchronized关键字x相关指令是monitorenter和monitorexit

2.可见性

volatile 修饰的变量；

synchronized 对一个变量执行unlock操作之前，必须先把此变量同步回主内存中(就是synchronized 锁住的对象需要在各个线程之间广而告之)

final 修饰的本来就不可变也就说可以有可见性

3.有序性

Java语言提供了volatile和synchronized两个关键字来保证线程之间操作的有序性；

volatile关键字本身就包含了禁止指令重排序的语义，

而synchronized则是由“一个变量在同一个时刻只允许一条线程对其进行lock操作”

3.6 先行发生原则

为Java语言中有一个“先行发生”（Happens-Before）的原则。这个原则非常重要，它是判断数据是否存在竞争，线程是否安全的非常有用的手段；

定义：先行发生是Java内存模型中定义的两项操作之间的偏序关系，比如说操作A先行发生于操作B，其实就是说在发生操作B之前，操作A产生的影响能被操作观察到，“影响”包括修改了内存中共享变量的值、发送了消息、调用了方法等；

程序次序规则：在一个线程内，按照控制流顺序，书写在前面的操作先行发生于书写在后面的操作

管程锁定规则：一个unlock操作先行发生于后面对同一个锁的lock操作，一个先unlock 了后面一个才能lock

volatile变量规则：对一个volatile变量的写操作先行发生于后面对这个变量的读操作

线程启动规则：Thread对象的start()方法先行发生于此线程的每一个动作

线程终止规则：线程中的所有操作都先行发生于对此线程的终止检测

线程中断规则：对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生

对象终结规则：一个对象的初始化完成（构造函数执行结束）先行发生于它的finalize()方法的开始

传递性：如果操作A先行发生于操作B，操作B先行发生于操作C，那就可以得出操作A先行发生于操作C的结论

4. Java与线程

4.1 线程的实现

主流的操作系统都提供了线程实现，Java语言则提供了在不同硬件和操作系统平台下对线程操作的统一处理,Java 使用的是Native ,表明无法使用平台无关的手段(基于操作系统了)；

实现线程主要有三种方式：使用内核线程实现（1：1实现），使用用户线程实现（1：N实现），使用用户线程加轻量级进程混合实现（N：M实现）

1.内核线程实现

内核线程（Kernel-Level Thread，KLT）就是直接由操作系统内核（Kernel，下称内核）支持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器（Scheduler）对线程进行调度，并负责将线程的任务映射到各个处理器上。每个内核线程可以视为内核的一个分身，这样操作系统就有能力同时处理多件事情，支持多线程的内核就称为多线程内核（Multi-Threads Kernel）

2.用户线程实现

为1：N实现。广义上来讲，一个线程只要不是内核线程，都可以认为是用户线程（User Thread，UT）的一种；用户线程的建立、同步、销毁和调度完全在用户态中完成，不需要内核的帮助，系统内核不能感知到用户线程的存在，操作可以是非常快速且低消耗的，也能够支持规模更大的线程数量；

缺点：线程的创建、销毁、切换和调度都是用户必须考虑的问题；

3.混合实现

内核线程与用户线程一起使用的实现方式，被称为N：M实现，既存在用户线程，也存在轻量级进程，操作系统支持的轻量级进程则作为用户线程和内核线程之间的桥梁，这样可以使用内核提供的线程调度功能及处理器映射，并且用户线程的系统调用要通过轻量级进程来完成，这大大降低了整个进程被完全阻塞的风险

4.Java线程的实现

商用Java虚拟机的线程模型普遍都被替换为基于操作系统原生线程模型来实现，即采用1：1的线程模型；