冯诺依曼计算机模型详解
现代计算机模型是基于-冯诺依曼计算机模型
计算机在运行时,先从内存中取出第一条指令,通过控制器的译码,按指令的要求,从存储器中取出数据进行指定的运算和逻辑操作等加工，然后再按地址把结果送到内存中去。接下来，再取出第二条指令,在控制器的指挥下完成规定操作。依此进行下去。直至遇到停止指令
程序与数据一样存贮，按程序编排的顺序,一步一步地取出指令,自动地完成指令规定的操作是计算机最基本的工作模型。 这一原理最初是由美籍匈牙利数学家冯.诺依曼于1945年提出来的，故称为冯.诺依曼计算机模型
计算机五大核心组成部分
-
控制器(Control)： 是整个计算机的中枢神经,其功能是对程序规定的控制信息进行解释,根据其要求进行控制,调度程序、数据、地址,协调计算机各部分工作及内存与外设的访问等
-
运算器(Datapath)： 运算器的功能是对数据进行各种算术运算和逻辑运算,即对数据进行加工处理
-
存储器(Memory)： 存储器的功能是存储程序、数据和各种信号、命令等信息,并在需要时提供这些信息
-
输入(Input system)： 输入设备是计算机的重要组成部分,输入设备与输出设备合你为外部设备,简称外设,输入设备的作用是将程序、原始数据、文字、字符、控制命令或现场采集的数据等信息输入到计算机。常见的输入设备有键盘、鼠标器、光电输入机、磁带机、磁盘机、光盘机等
-
输出(Output system)： 输出设备与输入设备同样是计算机的重要组成部分,它把外算机的中间结果或最后结果、机内的各种数据符号及文字或各种控制信号等信息输出出来。微机常用的输出设备有显示终端CRT、打印机、激光印字机、绘图仪及磁带、光盘机等
上面的模型是一个理论的抽象简化模型，它的具体应用就是现代计算机当中的硬件结构设计：
CPU指令结构
- ①. 控制单元:提供指令进行控制,比如我们要循环、逻辑的判断等(while、for、if等)
- ②. 运算单元:比如 1+1=2、2*3=6
- ③. 储存单元:主要存储的是:cpu缓存、寄存器(包含了两部分:指令和指令操作的数据),存的是正要计算的。 还有一些没有来得及计算的,或者准备要计算的,但是还没有读到CPU来,这部分指令和数据在内存中,只有cpu执行到这个程序,需要用到的时候,才会将数据和指令加载到储存单元来
CPU缓存结构
- 现代CPU为了提升执行效率,减少CPU与内存的交互(交互影响CPU效率),一般在CPU上集成了多级缓存架构,常见的为三级缓存结构: L1、L2是多核独享、L3是多核共享
- 存储器存储空间大小:
内存>L3>L2>L1>寄存器 - 存储器速度快慢排序:
寄存器>L1>L2>L3>内存
CPU读取存储器数据过程
- CPU要取寄存器X的值,只需要一步:直接读取
- CPU要取L1 cache的某个值,需要1-3步(或者更多):把cache行锁住,把某个数据拿来,解锁,如果没锁住就慢了
CPU要取L2 cache的某个值,先要到L1 cache里取,L1当中不存在,在L2里,L2开始加锁,加锁以后,把L2里的数据复制到L1,再执行读L1的过程,上面的3步,再解锁, 复制的过程可以理解为热点代码的替换 - CPU取L3 cache的也是一样,只不过先由L3复制到L2,从L2复制到L1,从L1到CPU
- CPU取内存则最复杂：通知内存控制器占用总线带宽,通知-内存加锁,发起内存读请求,等待回应,回应数据保存到L3(如果没有就到L2),再从L3/2到L1,再从L1到CPU,之后解除总线锁定
三级缓存的底层逻辑
- 时间局部性(Temporal Locality): 如果一个信息项正在被访问,那么在近期它很可能还会被再次访问
比如循环、递归、方法的反复调用等 - 空间局部性(Spatial Locality): 如果一个存储器的位置被引用，那么将来他附近的位置也会被引用
比如顺序执行的代码、连续创建的两个对象、数组等
CPU运行安全等级
①. CPU 有 4 个运行级别,分别为: ring0、ring1、ring2、ring3
②. Linux 与 Windows 只用到了2个级别:ring0、ring3。
- 操作系统内部内部程序指令通常运行在 ring0 级别,操作系统以外的第三方程序运行在 ring3 级别
- 第三方程序如果要调用操作系统内部函数功能,由于运行安全级别不够,必须切换CPU运行状态,从ring3切换到ring0,然后执行系统函数,说到这里相信同学们明白为什么JVM创建线程,线程阻塞唤醒是重型操作了,因为CPU要切换运行状态
③. 下面我大概梳理一下JVM创建线程CPU的工作过程
- CPU 从 ring3 切换 ring0 创建线程
- 创建完毕,CPU从 ring0 切换回 ring3
- 线程执行JVM程序
- 线程执行完毕，销毁还得切回 ring0
④. 我们的线程都有两个堆和栈,一个在用户空间(用户态)，一个在系统空间(系统态)。
- 如果我们不去调用系统库的话(比如开启一个线程),都是运行在用户空间,一旦你的线程需要阻塞,或者杀死,那么你的CPU状态就要从用户态切换到内核态,把操作系统的堆和栈给丢了，杀死掉(这个时候CPU的安全等级是ring0,ring0表示的是最高的等级)杀掉或者阻塞好了以后,又会从系统态(ring0)切回到用户态(ring3)
操作系统内存管理
①. 操作系统有用户空间与内核空间两个概念==,目的也是为了做到程序运行安全隔离与稳定==,以32位操作系统4G大小的内存空间为例
②. 由空间划分我们再引深一下,CPU调度的基本单位线程,也划分为：内核线程模型(KLT)、用户线程模型(ULT)
Java是内核线程模型(KLT)
上下文切换
①. 线程的上下文切换: 把上一个线程的中间状态保存,切换到另一个线程,这就是线程的上下文切换(这些中间状态保存在内存中(Task State Segment))
②. CPU在执行T1|T2两个线程的时候,实际上是分配时间周期的方式,在调度的时候,会给T1、T2分配时间,比如说T1是50ns、T2是100ns,在执行T1的时间片中,如果T1线程没有执行完毕,那么就会保存T1运行到此刻的中间状态保存(比如代码执行到哪里来了,就把到此刻的结果进行保存),然后再去执行T2)时间片轮转
虚拟机指令集架构
-
栈指令集架构(Java采用的是这样架构)
比如说我们执行1+2,会先将1先放到操作数栈中,然后从操作数栈中取出,放到局部变量表,将2放入操作数栈中,然后从操作数栈中取出,放到局部变量表。在将局部变量表的1和2取出放到操作数栈中计算 -
寄存器指令集架构(会非常快)
比如说我们执行1+2,那么直接将1和2从内存读到CPU中,然后进行相加得到结果,刷回内存中
JMM
定义
①. JMM(Java内存模型Java Memory Model,简称JMM)本身是一种抽象的概念 并不真实存在,它描述的是一组规则或规范通过规范定制了程序中各个变量(包括实例字段,静态字段和构成数组对象的元素)的访问方式。
②. 关键技术点都是围绕多线程的可见性、原子性、和有序性展开的。
③. JMM 提出的原因：
- 因为有这么多级的缓存(cpu和物理主内存的速度不一致的),CPU的运行并不是直接操作内存而是先把内存里边的数据读到缓存，而内存的读和写操作的时候就会造成不一致的问题。速度的不一致性
- Java虚拟机规范中试图定义一种Java内存模型(java Memory Model，简称JMM)来屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的内存访问效果。跨平台性，接口化
数据同步八大原子操作
一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节,Java内存模型定义了以下八种操作来完成
- lock(锁定): 作用于主内存的变量,把一个变量标记为一条线程独占状态
- unlock(解锁): 作用于主内存的变量,把一个处于锁定状态的变量释放出来,释放后 的变量才可以被其他线程锁定
- read(读取): 作用于主内存的变量,把一个变量值从主内存传输到线程的工作内存 中,以便随后的load动作使用
- load(载入): 作用于工作内存的变量,它把read操作从主内存中得到的变量值放入工 作内存的变量副本中
- use(使用): 作用于工作内存的变量,把工作内存中的一个变量值传递给执行引擎
- assign(赋值): 作用于工作内存的变量,它把一个从执行引擎接收到的值赋给工作内 存的变量
- store(存储): 作用于工作内存的变量,把工作内存中的一个变量的值传送到主内存 中,以便随后的write的操作
- write(写入): 作用于工作内存的变量,它把store操作从工作内存中的一个变量的值 传送到主内存的变量中
例子：
- 如果要把一个变量从主内存中复制到工作内存中,就需要按顺序地执行read和load操作
- 如果把变量从工作内存中同步到主内存中,就需要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行,而没有保证必须是连续执行
@Slf4j
public class CodeVisibility {
private static boolean initFlag = false;
private volatile static int counter = 0;
public static void refresh(){
log.info("refresh data.......");
initFlag = true;
log.info("refresh data success.......");
}
public static void main(String[] args){
Thread threadA = new Thread(()->{
while (!initFlag){
//System.out.println("runing");
counter++;
}
log.info("线程：" + Thread.currentThread().getName()
+ "当前线程嗅探到initFlag的状态的改变");
},"threadA");
threadA.start();
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
Thread threadB = new Thread(()->{
refresh();
},"threadB");
threadB.start();
}
}
JVMM 下的三大特性
可见性
-
①. 是指当一个线程修改了某一个共享变量的值,其他线程是否能够立即知道该变更, JVMM规定了所有的变量都存储在主内存中(假设有A、B两个线程同时去操作主物理内存的共享数据number=0,A抢到CPU执行权,将number刷新到自己的工作内存,这个时候进行number++的操作,这个时候number=1,将A中的工作内存中的数据刷新到主物理内存,这个时候,马上通知B,B重新拿到最新值number=1刷新B的工作内存中)
-
例子：
/* 笔记 * 1.当没有加Volatile的时候,while循环会一直在里面循环转圈 * 2.当加了之后Volatile,由于可见性,一旦num改了之后,就会通知其他线程 * 3.还有注意不能用if,if不会重新拉回来再判断一次。(也叫做虚假唤醒) * 4.案例演示:一个线程对共享变量的修改,另一个线程不能立即得到新值 * */ public class Video04_01 { public static void main(String[] args) { MyData myData = new MyData(); new Thread(() ->{ System.out.println(Thread.currentThread().getName() + "\t come in "); try { TimeUnit.SECONDS.sleep(3); } catch (InterruptedException e) { e.printStackTrace(); } //睡3秒之后再修改num,防止A线程先修改了num,那么到while循环的时候就会直接跳出去了 myData.addTo60(); System.out.println(Thread.currentThread().getName() + "\t come out"); },"A").start(); while(myData.num == 0){ //只有当num不等于0的时候,才会跳出循环 } } } class MyData{ int num = 0; public void addTo60(){ this.num = 60; } }由上面代码可以看出，并发编程时，会出现可见性问题，当一个线程对共享变量进行了修改，另外的线程并没有立即看到修改后的最新值。
这是由于每个线程获得都是共享变量的拷贝，需要对其操作完之后，才会重新复制到共享变量。
原子性
-
指一个操作是不可中断的,即多线程坏境下,操作不能被其他线程干扰
-
例子：
/** * <p> * 功能描述: volatile不保证原子性的代码验证 */ public class Video05_01 { public static void main(String[] args) { MyData03 myData03 = new MyData03(); for (int i = 0; i < 20; i++) { new Thread(() ->{ for (int j = 0; j < 1000; j++) { myData03.increment(); } },"线程" + String.valueOf(i)).start(); } //需要等待上面的20个线程计算完之后再查看计算结果 while(Thread.activeCount() > 2){ Thread.yield(); } System.out.println("20个线程执行完之后num:\t" + myData03.num); } } class MyData03{ static int num = 0; public void increment(){ num++; } } -
控制台输出：（由于并发不安全，每次执行的结果都可能不一样）
20个线程执行完之后num: 19706 -
使用
javap反汇编class文件，对于num++可以得到下面的字节码指令：9: getstatic #12 // Field number:I 取值操作 12: iconst_1 13: iadd 14: putstatic #12 // Field number:I 赋值操作由此可见num++是由多条语句组成，以上多条指令在一个线程的情况下是不会出问题的，但是在多线程情况下就可能会出现问题。
-
比如num刚开始值是7。A线程在执行13: iadd时得到num值是8，B线程又执行9: getstatic得到前一个值是7。马上A线程就把8赋值给了num变量。但是B线程已经拿到了之前的值7，B线程是在A线程真正赋值前拿到的num值。即使A线程最终把值真正的赋给了num变量，但是B线程已经走过了getstaitc取值的这一步，B线程会继续在7的基础上进行++操作，最终的结果依然是8。本来两个线程对7进行分别进行++操作，得到的值应该是9，因为并发问题，导致结果是8。
有序性
-
①. 计算机在执行程序时,为了提高性能,编译器和处理器常常会做指令重排,一把分为以下3种
-
②. 单线程坏境里面确保程序最终执行结果和代码顺序执行的结果一致
-
③. 处理器在进行重新排序是必须要考虑指令之间的数据依赖性
-
④. 多线程坏境中线程交替执行,由于编译器优化重排的存在,两个线程使用的变量能否保持一致是无法确认的,结果无法预测
多线程对变量的读写过程
读取过程
- 由于JVM运行程序的实体是线程,而每个线程创建时JVM都会为其创建一个工作内存(有些地方称为栈空间),工作内存是每个线程的私有数据区域,而Java内存模型中规定所有的变量都存储在主内存,主内存是共享内存区域
- 所有线程都可以访问,但线程对变量的操作(读取赋值等)必须在工作内存中进行,
- 首先要将变量从主内存拷贝到线程自己的工作内存空间,
- 然后对变量进行操作,操作完成后将变量写回主内存,不能直接操作主内存中的变量,各个线程的工作内存中存储着主内存中的变量副本拷贝,
- 因此不同的线程间无法访问对方的工作内存,线程间的通信(传值)必须通过主内存来完成,其简要访问过程如下图
JMM定义了线程和主内存之间的抽象关系
- 线程之间的共享变量存储在主内存中(从硬件角度来说就是内存条)
- 每个线程都有一个私有的本地工作内存,本地工作内存中存储了该线程用来读/写共享变量的副本(从硬件角度来说就是CPU的缓存,比如寄存器、L1、L2、L3缓存等)
小总结
- 我们定义的所有的共享变量都存储在物理主内存中，每个线程都有自己独立的工作内存,里面保存该线程使用到的变量的副本(主内存中该变量的一份拷贝)
- 线程对共享变量所有的操作都必须先在自己的工作内存中进行后写回主内存,不能直接从主内存中读写(不能越级)
- 不同线程之间也无法直接访问其他线程的工作内存中的变量,线程间变量值的传递需要通过主内存来进行(同级不能相互访问)
happens-before 原则
先行发生原则说明
我们编写的程序都要经过优化后（编译器和处理器会对我们的程序进行优化以提高运行效率）才会被运行，优化分为很多种，其中有一种优化叫做重排序，重排序需要遵守happens-before规则
happens-before部分规则如下：
- 1、程序顺序规则：一个线程中的每个操作happens-before于该线程中的任意后续操作
- 2、监视器锁（同步）规则：对于一个监视器的解锁，happens-before于随后对这个监视器的加锁
happens-before总原则
- 如果一个操作happens-before另一个操作, 那么第一个操作的执行结果对第二个操作可见, 而且第一个操作的执行顺序排在第二个操作之前(可见性,有序性)
- 两个操作之间存在 happens-before 关系,并不意味着一定要按照happens-before原则制定的顺序来执行。如果重排序之后的执行结果与按照happens-before关系来执行的结果一致,那么这种重排序并不非法(可以指令重排)
happens-before 的8条细则
-
①. 次序规则
一个线程内,按照代码顺序,写在前面的操作先行发生于写在后面的操作(强调的是一个线程)
前一个操作的结果可以被后续的操作获取。将白点就是前面一个操作把变量X赋值为1,那后面一个操作肯定能知道X已经变成了1 -
②. 锁定规则
一个unlock操作先行发生于后面((这里的"后面"是指时间上的先后)对同一个锁的lock操作(上一个线程unlock了,下一个线程才能获取到锁,进行lock)) -
③. volatile变量规则
对一个volatile变量的写操作先行发生于后面对这个变量的读操作,前面的写对后面的读是可见的,这里的"后面"同样是指时间是的先后 -
④. 传递规则
如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出A先行发生于操作C -
⑤. 线程启动规则(Thread Start Rule)
Thread对象的start( )方法先行发生于线程的每一个动作 -
⑥. 线程中断规则(Thread Interruption Rule)
对线程interrupt( )方法的调用先发生于被中断线程的代码检测到中断事件的发生
可以通过Thread.interrupted( )检测到是否发生中断 -
⑦. 线程终止规则(Thread Termination Rule)
线程中的所有操作都先行发生于对此线程的终止检测 -
⑧. 对象终结规则(Finalizer Rule)
对象没有完成初始化之前,是不能调用finalized( )方法的
例子
private int value=0;
public void setValue(){
this.value=value;
}
public int getValue(){
return value;
}
解决方案
- 把
getter/setter方法都定义synchronized方法(某一时刻只能有一个线程进入)。 - 把 value 定义为
volatile 变量, 由于setter方法对value的修改不依赖value的原值,满足volatile关键字的使用。 - 对一个volatile变量的写操作先行发生于后面对这个变量的读操作,前面的写对后面的读是可见的,这里的"后面"同样是指时间是的先后。
volatile
- 当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值立即刷新回主内存中。
- 当读一个volatile变量时，JMM会把该线程对应的本地内存设置为无效，直接从主内存中读取共享变量
所以volatile的写内存语义是直接刷新到主内存中，读的内存语义是直接从主内存中读取
volatile不保证原子性，只保证可见性和禁止指令重排
CPU术语介绍
在多线程下的单例模式中，我们必须使用 volatile 来创建共享数据：
private static volatile SingletonDemo instance = null;
private SingletonDemo() {
System.out.println(Thread.currentThread().getName() + "\t 执行单例构造函数");
}
public static SingletonDemo getInstance(){
if(instance == null){
synchronized (SingletonDemo.class){
if(instance == null){
instance = new SingletonDemo(); //pos_1
}
}
}
return instance;
}
pos_1处的代码转换成汇编代码如下：
0x01a3de1d: movb $0×0,0×1104800(%esi);
0x01a3de24: lock addl $0×0,(%esp);
volatile保证可见性原理
有 volatile 变量 修饰的共享变量进行写操作的时候会多出第二行汇编代码，通过查IA-32架 构软件开发者手册可知，Lock前缀的指令在多核处理器下会引发了两件事情。
- 1）将当前处理器缓存行的数据写回到系统内存。
- 2）这个写回内存的操作会使在其他CPU里缓存了该内存地址的数据无效。
为了提高处理速度，处理器不直接和主内存进行通信，而是先将系统内存的数据读到内部缓存（L1，L2或其他）后再进行操作，但操作完不知道何时会写到内存。
- 如果对声明了volatile的 变量进行写操作，JVM就会向处理器发送一条Lock前缀的指令，将这个变量所在缓存行的数据写回到系统内存。
- 但是，就算写回到内存，如果其他处理器缓存的值还是旧的，再执行计算操作就会有问题。所以，在多处理器下，为了保证各个处理器的缓存是一致的，就会实现MESI缓存一致性协议，
- 每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。
注意：lock前缀指令是同时保证可见性和有序性（也就是禁止指令重排）的
注意：lock前缀指令相当于一个内存屏障【后文讲】
内存屏障
定义
-
内存屏障（也称内存栅栏,内存栅障,屏障指令等,是一类同步屏障指令,是CPU或编译器在对内存随机访问的操作中的一个同步点,使得此点之前的所有读写操作都执行后才可以开始执行此点之后的操作）,避免代码重排序。
-
内存屏障其实就是一种JVM指令,Java内存模型的重排规则会要求Java编译器在生成JVM指令时插入特定的内存屏障指令,通过这些内存屏障指令,volatile实现了Java内存模型中的可见性和有序性,但volatile无法保证原子性
-
内存屏障之前的所有写操作都要回写到主内存
内存屏障之后的所有读操作都能获得内存屏障之前的所有写操作的最新结果(实现了可见性) -
一句话:对一个volatile域的写, happens-before于任意后续对这个volatile域的读,也叫写后读
四大内存屏障
- 内存屏障的落地需要靠 volatile关键字,而volatile关键字靠的是
StoreStore、StoreLoad 、LoadLoad、LoadStore四条指令 - 当我们的Java程序的变量被volatile修饰之后,会添加一个ACC_VOLATI LE,JVM会把字节码生成为机器码的时候,发现操作是volatile变量的话,就会根据JVM要求,在相应的位置去插入内存屏障指令
happens-before之volatile变量规则
- ①.当第一个操作为volatile读时,不论第二个操作是什么,都不能重排序。这个操作保证了volatile读之后的操作不会被重排到volatile读之前
- ②.当第二个操作为volatile写时,不论第一个操作是什么,都不能重排序。这个操作保证了volatile写之前的操作不会被重排到volatile写之后
- ③.当第一个操作为volatile写时,第二个操作为volatile读时,不能重排
JMM 就将内存屏障插⼊策略分为4种
①. 写
- 在每个volatile写操作的前⾯插⼊⼀个StoreStore屏障
- 在每个volatile写操作的后⾯插⼊⼀个StoreLoad屏障
②. 读
- 在每个volatile读操作的后⾯插⼊⼀个LoadLoad屏障
- 在每个volatile读操作的后⾯插⼊⼀个LoadStore屏障
例子
//模拟一个单线程，什么顺序读？什么顺序写？
public class VolatileTest {
int i = 0;
volatile boolean flag = false;
public void write(){
i = 2;
flag = true;
}
public void read(){
if(flag){
System.out.println("---i = " + i);
}
}
}
四大特性
①. 保证可见性
/*
验证volatile的可见性:
1.加入int number=0; number变量之前没有添加volatile关键字修饰,没有可见性
2.添加了volatile,可以解决可见性问题
* */
class Resource{
//volatile int number=0;
volatile int number=0;
public void addNumber(){
this.number=60;
}
}
public class Volatile_demo1 {
public static void main(String[] args) {
Resource resource=new Resource();
new Thread(()->{
System.out.println(Thread.currentThread().getName()+"\t coming ");
try {TimeUnit.SECONDS.sleep(4);}catch (InterruptedException e){e.printStackTrace();}
resource.addNumber();
System.out.println(Thread.currentThread().getName()+"\t update "+resource.number);
},"线程A").start();
//如果主线程访问resource.number==0,那么就一直进行循环
while(resource.number==0){
}
//如果执行到了这里,证明main现在通过resource.number的值为60
System.out.println(Thread.currentThread().getName()+"\t"+resource.number);
}
}
对于上面代码的结果如下所示：
-
不加volatile,没有可见性,程序无法停止
没有添加volatile关键字,线程A对共享变量改变了以后(number=60),主线程(这里的线程B)访问number的值还是0,这就是不可见 -
加了volatile,保证可见性,程序可以停止
添加volatile之后,线程A对共享数据进行了改变以后,那么main线程再次访问,number的值就是改变之后的number=60
②. 不保证原子性
下面代码 我们对20个线程进行循环100次的操作)：
/**
* <p>
* 功能描述: volatile不保证原子性的代码验证
*/
public class Video05_01 {
public static void main(String[] args) {
MyData03 myData03 = new MyData03();
for (int i = 0; i < 20; i++) {
new Thread(() ->{
for (int j = 0; j < 1000; j++) {
myData03.increment();
}
},"线程" + String.valueOf(i)).start();
}
//需要等待上面的20个线程计算完之后再查看计算结果
while(Thread.activeCount() > 2){
Thread.yield();
}
System.out.println("20个线程执行完之后num:\t" + myData03.num);
}
}
class MyData03{
volatile int num = 0;
public void increment(){
num++;
}
}
结果如下：
20个线程执行完之后num: 19928
实质上：
- 对于一读一写操作,不会有数据问题
- 对于两个写,会出现数据问题
read-load-use 和 assign-store-write 成为了两个不可分割的原子操作，但是在use和assign之间依然有极小的一段真空期，有可能变量会被其他线程读取，导致写丢失一次.
③. 禁止指令重排
重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段,有时候会改变程序语句的先后顺序(不存在数据依赖关系,可以重排序;存在数据依赖关系,禁止重排序)
重排序的分类和执行流程
- 编译器优化的重排序： 编译器在不改变单线程串行语义的前提下，可以重新调整指令的执行顺序
- 指令级并行的重排序: 处理器使用指令级并行技术来讲多条指令重叠执行，若不存在数据依赖性，处理器可以改变语句对应机器指令的执行顺序
- 内存系统的重排序: 由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上去可能是乱序执行
数据依赖性: 若两个操作访问同一变量,且这两个操作中有一个为写操作,此时两操作间就存在数据依赖性。
volatile 的使用场景
-
单一赋值可以,but 含复合运算赋值不可以(i++之类)
```java volatile int a = 10 volatile boolean flag = false ``` -
状态标志，判断业务是否结束
public class UseVolatileDemo{ private volatile static boolean flag = true; public static void main(String[] args){ new Thread(() -> { while(flag) { //do something...... } },"t1").start(); //暂停几秒钟线程 try { TimeUnit.SECONDS.sleep(2L); } catch (InterruptedException e) { e.printStackTrace(); } new Thread(() -> { flag = false; },"t2").start(); } } -
开销较低的读,写锁策略
public class UseVolatileDemo{ /** * 使用:当读远多于写，结合使用内部锁和 volatile 变量来减少同步的开销 * 理由:利用volatile保证读取操作的可见性;利用synchronized保证复合操作的原子性 */ public class Counter{ private volatile int value; public int getValue(){ return value; //利用volatile保证读取操作的可见性 } public synchronized int increment(){ return value++; //利用synchronized保证复合操作的原子性 } } }
单例模式 的线程安全
一.饿汉式单例(线程安全)
public class Singleton {
private static Singleton instance=null;
private Singleton() {};
public static synchronized Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
缺点：直接实例化，资源会浪费。丢失了延迟实例化的性能好处。
二.懒汉式单例(线程不安全)
public class Singleton {
private static Singleton instance=null;
private Singleton() {};
public static Singleton getInstance(){
if(instance==null){
instance=new Singleton();
}
return instance;
}
}
在运行过程中可能存在这么一种情况：多个线程去调用getInstance方法来获取 Singleton 的实例，那么就有可能发生这样一种情况。
- 当第一个线程在执行
if（instance==null）时，此时instance为null，进入语句。在还没有执行instance=new Singleton()时（此时instance是为null的）第二个线程也进入了if(instance==null)这个语句。 - 因为之前进入这个语句的线程中还没有执行
instance=new Singleton(),所以它会执行instance = new Singleton()来实例化Singleton对象,因为第二个线程也进入了if语句所以它会实例化Singleton对象。 - 这样就导致了实例化了两个Singleton对象。 所以单例模式的懒汉式是存在线程安全的问题。
三. 加锁的懒汉式（线程不安全）
public class Singleton7 {
private static Singleton instance=null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
instance = new Singleton();
}
}
return instance;
}
}
这种写法也是不安全的，当一个线程还没有实例化Singleton时另一个线程执行到if(instance == null)这个判断时语句机会进入if语句，==虽然加了锁，但是等到第一个线程执行完instance=new Singleton()跳出这个锁时，另一个进入if语句的线程同样会实例化另外一个SIngleton对象。==因为这种改进方法不可行。
四、DCL双端锁（串行下的多线程是安全的）
public class Singleton7 {
private static Singleton instance=null;
public static Singleton getInstance() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
为什么说上面这段代码在串行下安全，在并行下就安全呢？
主要问题出在 instance = new Singleton(); 这句话。
-
初始化实例的过程，可以由下面的伪代码表示：
memory=allocate();//1.分配对象内存空间 init(memory);//2.初始化对象 instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null -
但是由于上面代码中 2 和 3 其实不存在数据依赖关系，因此完全可以互换。由于因为互换位置后的结果不变，因此上列代码很有可能被重排列为下面形式：
memory=allocate();//1.分配对象内存空间 instance=memory;//3.设置instance的指向刚分配的内存地址,此时instance!=null 但对象还没有初始化完. instance(memory);//2.初始化对象 -
虽然重排列后的结果是不发生变化的。假设此时存在一个并行的线程（该线程不掌握任何锁），该线程会判断 instance 的执行是否为空，如果不为空则直接开始使用。 因此如果该线程面对的是重拍之后的字节指令，那么很有可能该线程会直接对一个 memory 中未被重写的其他对象进行操作。
-
因此该线程在并行下是不安全的
五、修改 DCL双端锁（并行下安全）
我们使用volatile禁止instance变量被执行指令重排优化即可
public class SafeDoubleCheckSingleton{
//通过volatile声明，实现线程安全的延迟初始化。
private volatile static SafeDoubleCheckSingleton singleton;
//私有化构造方法
private SafeDoubleCheckSingleton(){
}
//双重锁设计
public static SafeDoubleCheckSingleton getInstance(){
if (singleton == null){
//1.多线程并发创建对象时，会通过加锁保证只有一个线程能创建对象
synchronized (SafeDoubleCheckSingleton.class){
if (singleton == null){
//隐患：多线程环境下，由于重排序，该对象可能还未完成初始化就被其他线程读取
//原理:利用volatile，禁止 "初始化对象"(2) 和 "设置singleton指向内存空间"(3) 的重排序
singleton = new SafeDoubleCheckSingleton();
}
}
}
//2.对象创建完毕，执行getInstance()将不需要获取锁，直接返回创建对象
return singleton;
}
}
六：枚举单例（安全）
public enum SingleTon{
INSTANCE;
public void method(){
//TODO
}
}
枚举在java中与普通类一样，都能拥有字段与方法，而且枚举实例创建是线程安全的，在任何情况下，它都是一个单例。 我们可直接以 SingleTon.INSTANCE 的方式调用。
七、静态内部类实现（另外一种安全的懒汉式）
//基于类初始化的线程安全的单例
class SingleTon4{
private SingleTon4(){}
private static class InnerClass{
private static SingleTon4 instance= new SingleTon4();
}
public static SingleTon4 getInstance(){//如果没有到这里，那么不会加载上面的内部类
return InnerClass.instance; //这里将导致InstanceHolder类被初始化
}
}
静态内部类的优点是：
- 外部类加载时并不需要立即加载内部类，
- 内部类不被加载则不去初始化INSTANCE，故而不占内存。
- 具体来说当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，使用INSTANCE的时候,才会导致虚拟机加载SingleTonHoler类。这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。
拓展
静态内部类为什么是线程安全的？
首先要了解类加载过程中的最后一个阶段：即类的初始化， 类的初始化阶本质就是执行类构造器的<clinit>方法。
<clinit>方法：这不是由程序员写的程序，而是根据代码由javac编译器生成的。它是由类里面所有的类变量的赋值动作和静态代码块组成的。JVM内部会保证一个类的<clinit>方法在多线程环境下被正确的加锁同步，
- 也就是说如果多个线程同时去进行“类的初始化”，那么只有一个线程会去执行类的<clinit>方法，其他的线程都要阻塞等待，直到这个线程执行完<clinit>方法。
- 然后执行完<clinit>方法后，其他线程唤醒，但是不会再进入<clinit>()方法。也就是说同一个加载器下，一个类型只会初始化一次。
那么回到这个代码中，这里的静态变量的赋值操作进行编译之后实际上就是一个<clinit>代码。
-
当我们执行
getInstance方法的时候，会导致SingleTonHolder类的加载， -
类加载的最后会执行类的初始化，但是即使在多线程情况下，这个类的初始化的代码也只会被执行一次，所以他只会有一个实例。
-
那么再增加一句，之所以这里变量定义的时候不需要volatile，因为只有一个线程会执行具体的类的初始化代码<clinit>，也就是即使有指令重排序，因为根本没有第二个线程给你去影响，所以无所谓。
JVM在5种场景下的类加载
- 遇到new、getstatic、setstatic或者invokestatic这4个字节码指令时，对应的java代码场景为：new一个关键字或者一个实例化对象时、读取或设置一个静态字段时(final修饰、已在编译期把结果放入常量池的除外)、调用一个类的静态方法时。
- 使用
java.lang.reflect包的方法对类进行反射调用的时候，如果类没进行初始化，需要先调用其初始化方法进行初始化。 - 当初始化一个类时，如果其父类还未进行初始化，会先触发其父类的初始化。
- 当虚拟机启动时，用户需要指定一个要执行的主类(包含main()方法的类)，虚拟机会先初始化这个类。
- 当使用JDK 1.7等动态语言支持时，如果一个
java.lang.invoke.MethodHandle实例最后的解析结果REF_getStatic、REF_putStatic、REF_invokeStatic的方法句柄，并且这个方法句柄所对应的类没有进行过初始化，则需要先触发其初始化。
这5种情况被称为是类的主动引用，注意，这里《虚拟机规范》中使用的限定词是"有且仅有"，那么，除此之外的所有引用类都不会对类进行初始化，称为被动引用。静态内部类就属于被动引用的行列。
JVM-JMM-CPU底层执行全过程
(1). volatile保证可见性,在汇编会有一个lock锁前缀,触发缓存一致性协议,保证了可见性。缓存一致性协议中的MESI协议的状态的切换靠的是内存屏障的四条指令
(2). volatile保证有序性,是基于它底层的内存屏障,loadload、StoreLoad、LoadStore、StoreStore
JVM-JMM-CPU底层执行全过程
- ①. JVM(内存中)是基于栈的指令集架构,比如我们去执行一个运算的操作,最终是由CPU执行的
- ②. 比如sconst_0这个指令会交给执行引擎进行翻译,解释执行器或JLT转换为汇编
- ③. 汇编指令会转化为二进制
- ④. 在二进制下面是线程A,需要这个线程作为载体
- ⑤. cpu不是马上执行,而是CPU调度到线程A才执行线程A的代码
- ⑥. KLT模式,JVM创建一个线程,底层会维护一个线程表,而这个线程与JVM中的线程是一一对应的关系
缓存一致性协议
- ①. 变量加了volatile关键字,在汇编会有一个lock锁前缀(触发硬件缓存锁机制)
硬件缓存锁机制包含总线锁、缓存一致性协议 - ②. 早期技术落后,使用总线保持缓存一致
例子: 早期可能CPU还没有三级缓存,t1、t2两个线程(多核)对主内存中的数据进行修改,如果某一个时刻,t1线程拿到了CPU执行权,在写回到主内存去的时候,会将总线锁抢占,抢占后t2线程就没办法去进行写入的操作。早期的这种使用总线锁的效率很低,它只能保证一个线程去写,这样多核的也就没办法发挥写操作 - ③. 缓存一致性协议(最经典的是MESI协议)
mesi 在硬件约定了这样一种机制,CPU启动后,会采用一种监听模式,一直去监听总线里面消息的传递,也就是说,有任何人通过总线从内存中拿了一点东西,只要你被lock前缀修饰了,都可以感知到
主要信号：Modified、Exclusive、Shared、Invalid
例如 我们对主内存的数据x=0,t1线程进行赋值x=3,t2线程进行赋值x=5的操作
- 首先t1线程将x=0从内存–总线–读到三级缓存中,放入缓存行中存储,这时状态是
E(独享的) - t2线程也将x=0从内存–总线–读到三级缓存中,放入缓存行中存储,这时的状态是
S(共享的),而t1线程读取到的也从E–S - 这个时候t1将数据从3级缓存读到L2—L1中,t2线程也是如此
- 情况一：此时如果t1上锁的话,那么会将t1的L1的缓存行锁住,然后将x=3(E-S-M),在写的同时,发出一个通知去告诉t2线程,这个时候t2线程就会将变量置为无效(S-I),也发出一个通知去通知线程t1的cpu,告诉它我这里置为无效了,读取到t1线程的x=3。
至于什么时候t1线程将值写入主内存的时机是不确定的t1线程写操作后，回向其他线程发生通知，将 其他线程设置为无效。 - 情况二：线程t1和线程t2同时都锁住了各自L3中的缓存行,这个时候,我们到底是执行谁的结果呢？这个时候由总线裁决,看执行谁的操作,是x=3还是x=5
总线裁决: 通过总线上面电路的高低电位,每一个cpu都有自己的时钟周期 - 情况三:如果变量很大,我们一个缓存行存不进去,这个时候MESI就会失效,会降级到总线的机制
234
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
