zxpnet网站
shollin
2021-08-14
目录

jmm和volatile

# 现代计算机理论模型与工作方式

image-20210814160126106

image-20210814160626882

参考文章：现代计算机理论模型与工作原理_瑞文のBlog-CSDN博客 (opens new window)

主要了解： cpu与内存之间的交互通信

image-20210816153145216

image-20210814163145230

# 数据加载的流程如下：

1.将程序和数据从硬盘加载到内存中

2.将程序和数据从内存加载到缓存中(目前多三级缓存，数据加载顺序:L3->L2->L1)

3.CPU将缓存中的数据加载到寄存器中，并进行运算

4.CPU会将数据刷新回缓存，并在一定的时间周期之后刷新回内存

# 缓存一致性协议

参考文章： 缓存一致性协议（MESI） - 一念永恒乐 - 博客园 (cnblogs.com) (opens new window)

# 缓存一致性协议发展背景

现在的CPU基本都是多核CPU，服务器更是提供了多CPU的支持，而每个核心也都有自己独立的缓存，当多个核心同时操作多个线程对同一个数据进行更新时，如果核心2在核心1还未将更新的数据刷回内存之前读取了数据，并进行操作，就会造成程序的执行结果造成随机性的影响，这对于我们来说是无法容忍的。

而总线加锁是对整个内存进行加锁，在一个核心对一个数据进行修改的过程中，其他的核心也无法修改内存中的其他数据，这样对导致CPU处理性能严重下降。

缓存一致性协议提供了一种高效的内存数据管理方案，它只会对单个缓存行（缓存行是缓存中数据存储的基本单元）的数据进行加锁，不会影响到内存中其他数据的读写。因此，我们引入了缓存一致性协议来对内存数据的读写进行管理。

# MESI协议

缓存一致性协议有MSI，MESI，MOSI，Synapse，Firefly及DragonProtocol等等，接下来我们主要介绍MESI协议。

MESI分别代表缓存行数据所处的四种状态，通过对这四种状态的切换，来达到对缓存数据进行管理的目的。

状态 描述 监听任务
M 修改（Modify） 该缓存行有效，数据被修改了，和内存中的数据不一致，数据只存在于本缓存行中 缓存行必须时刻监听所有试图读该缓存行相对应的内存的操作，其他缓存须在本缓存行写回内存并将状态置为E之后才能操作该缓存行对应的内存数据
E 独享、互斥（Exclusive） 该缓存行有效，数据和内存中的数据一致，数据只存在于本缓存行中 缓存行必须监听其他缓存读主内存中该缓存行相对应的内存的操作，一旦有这种操作，该缓存行需要变成S状态
S 共享（Shared） 该缓存行有效，数据和内存中的数据一致，数据同时存在于其他缓存中 缓存行必须监听其他缓存是该缓存行无效或者独享该缓存行的请求，并将该缓存行置为I状态
I 无效（Invalid） 该缓存行数据无效 无

备注：

1.MESI协议只对汇编指令中执行加锁操作的变量有效，表现到java中为使用voliate关键字定义变量或使用加锁操作

2.对于汇编指令中执行加锁操作的变量，MESI协议在以下两种情况中也会失效：

一、CPU不支持缓存一致性协议。

二、该变量超过一个缓存行的大小，缓存一致性协议是针对单个缓存行进行加锁，此时，缓存一致性协议无法再对该变量进行加锁，只能改用总线加锁的方式。

MESI工作原理：（此处统一默认CPU为单核CPU，在多核CPU内部执行过程和一下流程一致）

1、CPU1从内存中将变量a加载到缓存中，并将变量a的状态改为E（独享），并通过总线嗅探机制对内存中变量a的操作进行嗅探

2、此时，CPU2读取变量a，总线嗅探机制会将CPU1中的变量a的状态置为S（共享），并将变量a加载到CPU2的缓存中，状态为S

3、CPU1对变量a进行修改操作，此时CPU1中的变量a会被置为M（修改）状态，而CPU2中的变量a会被通知，改为I（无效）状态，此时CPU2中的变量a做的任何修改都不会被写回内存中（高并发情况下可能出现两个CPU同时修改变量a，并同时向总线发出将各自的缓存行更改为M状态的情况，此时总线会采用相应的裁决机制进行裁决，将其中一个置为M状态，另一个置为I状态，且I状态的缓存行修改无效）

4、CPU1将修改后的数据写回内存，并将变量a置为E（独占）状态

5、此时，CPU2通过总线嗅探机制得知变量a已被修改，会重新去内存中加载变量a，同时CPU1和CPU2中的变量a都改为S状态

当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

嗅探: 每个处理器通过嗅探在总线上传播的数据来检查自己缓存的值是不是过期了，当处理器发现自己缓存行对应的内存地址被修改，就会将当前处理器的缓存行设置成无效状态，当处理器对这个数据进行修改操作的时候，会重新从系统内存中把数据读到处理器缓存里。

总线风暴: 由于Volatile的MESI缓存一致性协议，需要不断的从主内存嗅探和cas不断循环，无效交互会导致总线带宽达到峰值。

参考：阿里面试官没想到，一个Volatile我能跟他扯半个小时 - 知乎 (zhihu.com) (opens new window)

# 线程与进程

参考文章 ：CPU 的 ring0，ring1,ring2,ring3_tian5753的博客-CSDN博客_ring (opens new window)

进程与线程的一个简单解释 - 阮一峰的网络日志 (ruanyifeng.com) (opens new window)

多线程上下文切换 - 割肉机 - 博客园 (cnblogs.com) (opens new window)

深入理解Linux内核进程上下文切换_宋宝华-CSDN博客 (opens new window)

现代操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作系统就会创建一个Java进程。现代操作系统调度CPU的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉到这些线程在同时执行。

线程的实现可以分为两类： 1、用户级线程(User-Level Thread) 2、内核线线程(Kernel-Level Thread)

image-20210816141135371

image-20210816142311293

image-20210816145425382

cpu一次只运行一个线程，当线程一运行时间用完时，会将指令、运行结果数据等保存到内核空间的tss上，当时间片再切换回线程1时，又从tss里面取出之前保存的数据。这就是上下文切换。

# 并发产生的问题：

•高并发场景下，导致频繁的上下文切换

•临界区线程安全问题，容易出现死锁的，产生死锁就会造成系统功能不可用

•其它

# 如何查看线程里面的死锁？

jps  #查看运行的java进程 
jstack 进程号
1
2

# JMM模型

JMM与JVM内存区域的划分是不同的概念层次，更恰当说JMM描述的是一组规则，通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式，JMM是围绕原子性，有序性、可见性展开。

image-20210816151425484

jmm理解： 线程运行在cpu上，工作内存相当于cpu的L1、L2、L3缓存，主内存就是内存条，

参考：JVM内存结构和JMM内存模型_迁就100-CSDN博客 (opens new window)

image-20210820112257194

# 主内存

主要存储的是Java实例对象，所有线程创建的实例对象都存放在主内存中，不管该实例对象是成员变量还是方法中的本地变量(也称局部变量)，当然也包括了共享的类信息、常量、静态变量。由于是共享数据区域，多条线程对同一个变量进行访问可能会发生线程安全问题。

# 工作内存

主要存储当前方法的所有本地变量信息(工作内存中存储着主内存中的变量副本拷贝)，每个线程只能访问自己的工作内存，即线程中的本地变量对其它线程是不可见的，就算是两个线程执行的是同一段代码，它们也会各自在自己的工作内存中创建属于当前线程的本地变量，当然也包括了字节码行号指示器、相关Native方法的信息。注意由于工作内存是每个线程的私有数据，线程间无法相互访问工作内存，因此存储在工作内存的数据不存在线程安全问题。 根据JVM虚拟机规范主内存与工作内存的数据存储类型以及操作方式，对于一个实例对象中的成员方法而言，如果方法中包含本地变量是基本数据类型 （boolean,byte,short,char,int,long,float,double），将直接存储在工作内存的帧栈结构中，但倘若本地变量是引用类型，那么该变量的引用会存储在功能内存的帧栈中，而对象实例将存储在主内存(共享数据区域，堆)中。但对于实例对象的成员变量，不管它是基本数据类型或者包装类型(Integer、Double等)还是引用类型，都会被存储到堆区。至于static变量以及类本身相关信息将会存储在主内存中。需要注意的是，在主内存中的实例对象可以被多线程共享，倘 若两个线程同时调用了同一个对象的同一个方法，那么两条线程会将要操作的数据拷贝一份到自己的工作内存中，执行完成操作后才刷新到主内存 模型如下图所示

image-20210820112605993

# JMM八大内存操作

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内存模型只要求上述8大操作(原子操作)必须按顺序执行，而没有保证必须是连续执行。

工作内存是每个线程的私有数据区域，里面的数据是安全的，不同的线程间无法访问对方的工作内存，线程间的通信(传值)必须通过主内存来完成。

主内存里面的数据是线程共享的，多条线程对同一个变量进行访问可能会发生线程安全问题

image-20210816155020097

# JMM内存同步规则

1.不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中

2.一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或者assign）的变量。即就是对一个变量实施use和store操作之前，必须先自行assign和load操作。

3.一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现。

4.如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量之前需要重新执行load或assign操作初始化变量的值。

5.如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。

6.对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）

# volatile

# volatile原理与内存语义

1、volatile是Java虚拟机提供的轻量级的同步机制

2、volatile语义有如下两个作用

•可见性：保证被volatile修饰的共享变量对所有线程总数可见的，也就是当一个线程修改了一个被volatile修饰共享变量的值，新值总是可以被其他线程立即得知。

•有序性：禁止指令重排序优化。

3、volatile缓存可见性实现原理

•JMM内存交互层面：volatile修饰的变量的read、load、use操作和assign、store、write必须是连续的，即修改后必须立即同步回主内存，使用时必须从主内存刷新，由此保证volatile变量的可见性。

•底层实现：通过汇编lock前缀指令，它会锁定变量缓存行区域并写回主内存，这个操作称为“缓存锁定”，缓存一致性机制会阻止同时修改被两个以上处理器缓存的内存区域数据。一个处理器的缓存回写到内存内存会导致其他处理器的缓存无效

4、volatile保证可见性与有序性，但是不能保证原子性，要保证原子性需要借助synchronized、Lock锁机制，同理也能保证有序性与可见性。因为synchronized和Lock能够保证任一时刻只有一个线程访问该代码块。

当一个共享变量被volatile修饰时，它会保证修改的值立即被其他的线程看到，即修改的值立即更新到主存中，当其他线程需要读取时，它会去内存中读取新值。

参考：Java并发编程：volatile关键字解析 - Matrix海子 - 博客园 (cnblogs.com) (opens new window)

# 指令重排

参考： JVM之指令重排分析_木小鱼的笔记-CSDN博客_指令重排 (opens new window)

在计算机执行指令的顺序在经过程序编译器编译之后形成的指令序列，一般而言，这个指令序列是会输出确定的结果；以确保每一次的执行都有确定的结果。但是，一般情况下，CPU和编译器为了提升程序执行的效率，会按照一定的规则允许进行指令优化，在某些情况下，这种优化会带来一些执行的逻辑问题，主要的原因是代码逻辑之间是存在一定的先后顺序，在并发执行情况下，会发生二义性，即按照不同的执行逻辑，会得到不同的结果信息。

# 指令重排在并发时的坑

单例模式

/**
 * 创建单例
 *
 */
public class Singleton {
	private Singleton() {}
	
	private volatile static Singleton myinstance;

    public static Singleton getInstance() {
        if (myinstance == null) {
            synchronized (Singleton.class) {
                if (myinstance == null) {
                    myinstance = new Singleton();   
                }
            }
        }
        return myinstance;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

分析：

创建对象Singleton时，会有延时操作，实质上发生了三步：1分配内存空间、2创建对象、3赋值，这三步非原子性操作，在大量并发情况下，会发生指令重排，如1-3-2，造成对象为空，因此需要将myinstance变成volatile变量，杜绝了指令重排。

设计模式--单例模式（二）双重校验锁模式 - ·卿欢· - 博客园 (cnblogs.com) (opens new window)

【单例模式】猛男因不懂单例模式，被面试官无情嘲讽_哔哩哔哩_bilibili (opens new window)

# 内存屏障

参考：Java内存模型Cookbook（二）内存屏障 | 并发编程网 – ifeve.com (opens new window)

内存屏障，又称内存栅栏，是一个CPU指令，它的作用有两个，一是保证特定操作的执行顺序，二是保证某些变量的内存可见性（利用该特性实现volatile的内存可见性）。由于编译器和处理器都能执行指令重排优化。如果在指令间插入一条Memory Barrier则会告诉编译器和CPU，不管什么指令都不能和这条Memory Barrier指令重排序，也就是说通过插入内存屏障禁止在内存屏障前后的指令执行重排序优化。Memory Barrier的另外一个作用是强制刷出各种CPU的缓存数据，因此任何CPU上的线程都能读取到这些数据的最新版本。

# 内存屏障的种类

几乎所有的处理器至少支持一种粗粒度的屏障指令，通常被称为“栅栏（Fence）”，它保证在栅栏前初始化的load和store指令，能够严格有序的在栅栏后的load和store指令之前执行。无论在何种处理器上，这几乎都是最耗时的操作之一（与原子指令差不多，甚至更消耗资源），所以大部分处理器支持更细粒度的屏障指令。

内存屏障的一个特性是将它们运用于内存之间的访问。尽管在一些处理器上有一些名为屏障的指令，但是正确的/最好的屏障使用取决于内存访问的类型。下面是一些屏障指令的通常分类，正好它们可以对应上常用处理器上的特定指令（有时这些指令不会导致操作）。

# 1、LoadLoad 屏障

序列：Load1,Loadload,Load2

确保Load1所要读入的数据能够在被Load2和后续的load指令访问前读入。通常能执行预加载指令或/和支持乱序处理的处理器中需要显式声明Loadload屏障，因为在这些处理器中正在等待的加载指令能够绕过正在等待存储的指令。 而对于总是能保证处理顺序的处理器上，设置该屏障相当于无操作。

# 2、StoreStore 屏障

序列：Store1，StoreStore，Store2

确保Store1的数据在Store2以及后续Store指令操作相关数据之前对其它处理器可见（例如向主存刷新数据）。通常情况下，如果处理器不能保证从写缓冲或/和缓存向其它处理器和主存中按顺序刷新数据，那么它需要使用StoreStore屏障。

# 3、LoadStore 屏障

序列： Load1; LoadStore; Store2

确保Load1的数据在Store2和后续Store指令被刷新之前读取。在等待Store指令可以越过loads指令的乱序处理器上需要使用LoadStore屏障。

# 4、StoreLoad屏障

序列: Store1; StoreLoad; Load2

确保Store1的数据在被Load2和后续的Load指令读取之前对其他处理器可见。StoreLoad屏障可以防止一个后续的load指令 不正确的使用了Store1的数据，而不是另一个处理器在相同内存位置写入一个新数据。正因为如此，所以在下面所讨论的处理器为了在屏障前读取同样内存位置存过的数据，必须使用一个StoreLoad屏障将存储指令和后续的加载指令分开。Storeload屏障在几乎所有的现代多处理器中都需要使用，但通常它的开销也是最昂贵的。它们昂贵的部分原因是它们必须关闭通常的略过缓存直接从写缓冲区读取数据的机制。这可能通过让一个缓冲区进行充分刷新（flush）,以及其他延迟的方式来实现。

# 如何加内存屏障

方法一：变量加上volatile关键字

方法二：手动加内存屏障 Unsafe

/**
 * 通过自身的反射拿到Unsafe对象
 */
public class UnsafeInstance {
    public static Unsafe reflectGetUnsafe() {
        try {
            Field field = Unsafe.class.getDeclaredField("theUnsafe");
            field.setAccessible(true);
            return (Unsafe) field.get(null);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//手动加内存屏障
UnsafeInstance.reflectGetUnsafe().storeFence();
1
2

image-20210818150758708

image-20210818153309671

# 小技巧

# 1、IDEA如何查看运行Java代码生成的汇编指令

需要下载的工具：hsdis-amd64.dll (opens new window) 提取码：mdhj

1）把 hsdis-amd64.dll放在 $JAVA_HOME/jre/bin/server 目录下

2）运行时可添加参数： -XX:+UnlockDiagnosticVMOptions -XX:+PrintAssembly -Xcomp。

IDEA如何查看运行Java代码生成的汇编指令 - 小破孩楼主 - 博客园 (cnblogs.com) (opens new window)

# 2、

南航面试题
Synchronized&Lock&AQS详解

← Synchronized&Lock&AQS详解→

最近更新
01
国际象棋
09-15
02
成语
09-15
03
自然拼读
09-15
更多文章>
Theme by Vdoing | Copyright © 2019-2023 zxpnet | 粤ICP备14079330号-1