352-细说Java多线程之内存可见性
https://www.imooc.com/learn/352
简介:本课程带领大家深层次学习Java中的内存可见性、Java内存模型、指令重排序、as-if-serial语义等多线程中偏向底层的一些知识,以及synchronized和volatile实现内存可见性的原理和方法。
目录
第1章 课程简介
介绍课程目标和学习内容
多线程-数据争用-内存可见性
- 共享变量在线程间的可见性
synchronized
实现可见性volatile
实现可见性- 指令重排序
as-if-serial
语义volatile
使用注意事项
synchronized
和volatile
比较
第2章 可见性介绍
本章讲解Java内存模型,可见性的概念和可见性实现的原理
2-1 可见性介绍
可见性:一个线程对共享变量值的修改,能够及时地被其他线程看到。
共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量。
线程的工作内存:
Java
内存抽象出来的概念Java
内存模型(JMM
)Java
内存模型(Java Memory Model
)描述了Java
程序中各种变量(线程共享变量)的访问规则,以及在JVM
中将变量存储到内存和从内存中读取出变量这样的底层细节。所有的变量都存储在主内存中
每个线程都有自己独立的工作内存,里面保存该线程使用到的变量的副本(主内存中该变量的一份拷贝)
共享变量使用的两条规则
- 线程对共享变量的所有操作都必须在自己的工作内存中进行,不能直接从主内存中读写
- 不同线程之间无法直接访问其他线程工作内存中的变量,线程间变量值的传递需要通过主内存来完成
共享变量可见性实现的原理
线程1对共享变量的修改要想被线程2及时看到,必须经过如下2个步骤:
把工作内存1中更新过的共享变量刷新到主内存中
将主内存中最新的共享变量的值更新到工作内存2中
线程1–>工作内存1中变量
X
–>更新到主内存中–>工作内存2中的变量X
得到更新–>线程2
2-2 练习题
下面叙述错误的是:B
A. 通过
synchronized
和volatile
都可以实现可见性B. 不同线程之间可以直接访问其他线程工作内存中的变量
C. 线程对共享变量的所有操作都必须在自己的工作内存中进行
D. 所有的变量都存储在主内存中
第3章 synchronized
实现可见性
本章讲解synchronized实现可见性的原理和方法、指令重排序、as-if-serial语义等概念,并通过具体程序进行分析。
3-1 synchronized
实现可见性原理
要实现共享变量的可见性,必须保证两点:
- 线程修改后的共享变量值能够及时从工作内存刷新到主内存中
- 其他线程能够及时把共享变量的最新值从主内存更新到自己的工作内存中
Java语言层面支持的可见性实现方式:
synchronized
、volatile
- synchronized能够实现:原子性(同步)、可见性
- JMM关于synchronized的两条规定:
- 线程解锁前,必须把共享变量的最新值刷新到主内存中。
- 线程加锁时,将清空工作内存中共享变量的值,从而使用共享变量时需要从主存中重新读取最新的值。(注意:加锁与解锁需要是同一把锁)
线程解锁前对共享变量的修改在下次加锁时对其他线程可见。
线程执行互斥代码块的过程:
- 获得互斥锁
- 清空工作内存
- 从主内存拷贝变量的最新副本到工作内存
- 执行锁内代码
- 将更改后的共享变量值刷新到主内存
- 释放互斥锁
指令重排序
重排序:代码的书写顺序与实际执行的顺序不同,指令重排序是编译器或处理器为了提高程序性能而做的优化
- 编译器优化的重排序(编译器优化)重新安排代码的执行顺序
- 指令级并行的重排序(处理器优化)双核处理器采用了指令级并行技术,可执行多条指令
- 内存系统的重排序(处理器优化)对读写缓存做的优化
//代码顺序: //执行顺序: int number = 1; int result = 0; int result = 0; int number = 1;
as-if-serial
:无论如何重排序,程序执行的结果应该与代码顺序执行的结果一致(Java
编译器都会保证Java
在单线程下遵循as-if-serial
语义)
注:
- 重排序不会给单线程带来内存可见性问题
- 多线程中程序交错执行时,重排序可能会造成内存可见性问题
3-2 synchronized
实现可见性代码
ready = false;
result = 0;
number = 1;
// 写操作
public void write() {
ready = true; // 1.1
number = 2; // 1.2
}
//读操作
public void read() {
if (ready) { // 2.1
result = number * 3;//2.2
}
System.out.println("result的值为:" + result);
}
执行顺序:
- 1.1–>2.1–>2.2–>1.2
result=3; - 1.2–>2.1–>2.2–>1.1
result=0;
导致共享变量在线程间不可见的原因:
- 线程的交叉执行
- 重排序结合线程交叉执行
- 共享变量更新后的值没有在工作内存与主内存间及时更新
synchronized解决不可见的方案:
- 原子性:由于锁的关系,线程之间不允许交叉执行;相当于给该线程(或当前运行的有且仅有一个的线程)加了一把锁,外面的线程无法进入,更别提互相交叉执行。
- 原子性 +
as-if-serial
语义:线程不能交叉执行,重排序对于单线程不能影响运行结果。 - 可见性:共享变量的更新执行。
常见问题:
- 为何不加
synchronized
关键字也会执行可见性,是主内存及时更新被获取最新值么?
因为当时定义说加synchronized
一定会可见性,而不加也没说一定不会,只是有可能不会。因为现在Java
做了一些优化:尽量实现可见性;但是不能保证每次都成功,只是成功概率比较大99%,但还是有1%的情况会失败。所以处于安全性考虑,尽量加synchronized
关键字100%成功。 - 有时候不存在线程交叉情况,但是会先执行第二个线程,这是因为第一个线程把
CPU
让位出来。所以为了避免这种情况,可以在第一个线程后附上代码:sleep(1000);
1秒之后才有机会执行线程2。 synchronized
+sleep();
黄金搭档。3-5 练习题
下面说法错误的是:CA. 当两个并发线程访问同一个对象
object
中的这个synchronized(this)
同步代码块时,一个时间内只能有一个线程得到执行。B. 当一个线程访问
object
的一个synchronized(this)
同步代码块时,另一个线程仍然可以访问该object
中的非synchronized(this)
同步代码块。C. 当一个线程访问
object
的一个synchronized(this)
同步代码块时,其他线程对object
中所有其它synchronized(this)
同步代码块的访问不会被阻塞。D. 当一个线程访问
object
的一个synchronized(this)
同步代码块时,它就获得了这个object
的对象锁。结果,其它线程对该object
对象所有同步代码块部分的访问都被暂时阻塞。
第4章 volatile
实现可见性
本章讲解volatile实现可见性的原理和方法,以及需要使用volatile时需要注意的事项,并通过具体程序进行分析。
4-1 volatile
能够保证可见性
volatile
关键字:- 能够保证
volatile
变量的可见性。 - 不能保证
volatile
变量复合操作的原子性。
- 能够保证
volatile
如何实现内存可见性:通过加入内存屏障和禁止重排序优化来实现的。
对
volatile
变量执行写操作时,会在写操作后加入一条store
屏障指令。对
volatile
变量执行读操作时,会在读操作前加入一条load
屏障指令。Java
内存模型中一共定义了8条操作指令来完成主内存和工作内存的交互★通俗地讲:
volatile
变量在每次被线程访问时,都强迫从主内存中重读该变量的值,而当该变量发生变化时,又会强迫线程将最新的值刷新到主内存。这样任何时候,不同的线程总能看到该变量的最新值线程读/写
volatile
变量的过程:- 线程写
volatile
变量的过程:- 改变线程工作内存的中
volatile
变量副本的值。 - 将改变后的副本的值从工作内存刷新到主内存。
- 改变线程工作内存的中
- 线程读
volatile
变量的过程:- 从主内存中读取
volatile
变量的最新值到线程的工作内存中。 - 从工作内存中读取
volatile
变量的副本。
- 从主内存中读取
- 线程写
volatile
不能保证volatile
变量复合操作的原子性number++;
的步骤:- 读取
number
的值 - 将
number
的值加1 - 写入最新的
number
的值private int number = 0; number++;//不是原子操作
- 读取
加入
synchronized
,变为原子操作synchronized(this){ number++; }
变为
volatile
变量,无法保证原子性private volatile int number = 0;
4-2 volatile
不能保证原子性
例:
number = 5
线程
A
读取number
的值 A=5 B=N M=5线程
B
读取number
的值 A=5 B=5 M=5线程
B
执行加1操作 A=5 B=6 M=5线程
B
写入最新的number
的值 A=5 B=6 M=6线程
A
执行加1操作 A=6 B=6 M=6线程
A
写入最新的number
的值 A=6 B=6 M=6两次
number++
只增加了1
解决方案:
保证
number
自增操作的原子性:
使用
synchronized
关键字synchronized (this) { this.number++; }
使用
ReentrantLock
(java.util.concurrent.locks
包下),最好使用try-finally
private Lock lock = new ReentrantLock(); lock.lock(); try { this.number++; } finally { lock.unlock(); }
使用
AtomicInteger
(java.util.concurrent.atomic
包下)private AtomicInteger num = new AtomicInteger(0); num.getAndAdd(1);
4-5 volatile
使用注意事项
要在多线程中安全的使用volatile
变量,必须同时满足:
对变量的写入操作不依赖其当前值
不满足:
number++
、count=count*5
等
满足:boolean
变量、记录温度变化的变量等该变量没有包含在具有其他变量的不变式中
不满足:不变式
low<up
4-6 synchronized
与volatile
比较
volatile
不需要加锁,比synchronized
更轻量级,不会阻塞线程- 从内存可见性角度讲:
volatile
读操作相当于加锁;volatile
写操作相当于解锁 synchronized
既能保证可见性,又能保证原子性;而volatile
只能保证可见性,无法保证原子性
总而言之:synchronized
稳定性高,效率低;volatile
稳定性低,效率高。
4-7 练习题
下列说法中错误的是:A
A.
volatile
是保证被修饰变量的可见性,同时也保证原子操作
B.Java
中没有提供检测与避免死锁的专门机制,但应用程序员可以采用某些策略防止死锁的发生
C.JAVA
中对共享数据操作的并发控制是采用加锁技术
D. 共享数据的访问权限都必须定义为private
第5章 课程总结
总结本门课程的学习内容
总结:
- 什么是内存可见性
Java
内存模型(JMM
)- 实现可见性的方式:
synchronized
和volatile
final
也可以保证内存的可见性
synchronized
和volatile
实现内存可见性的原理synchronized
实现可见性- 指令重排序
as-if-serial
语义
volatile
实现可见性volatile
能够保证可见性volatile
不能保证原子性(number++
)volatile
使用注意事项
- synchronized和volatile比较
- volatile比synchronized更轻量级
- synchronized比volatile使用更广泛
补充:
问:即使没有保证可见性的措施(如s
ynchronized
、volatile
、final
),很多时候共享变量依然能够在主内存和工作内存见得到及时的更新?答:一般只有在短时间内高并发的情况下才会出现变量得不到及时更新的情况,因为
CPU
在执行时会很快地刷新缓存,所以一般情况下很难看到这种问题。对64位(
long
、double
)变量的读写可能不是原子操作:Java
内存模型允许JVM
将没有被volatile
修饰的64位数据类型的读写操作划分为两次32位的读写操作来进行导致问题:有可能会出现读取到“半个变量”的情况
解决方法:加
volatile
关键字注:目前几乎所有虚拟机已经把64位数据的读写做了原子操作,不需将(
long
、double
)使用volatile
修饰
转载请注明来源,欢迎对文章中的引用来源进行考证,欢迎指出任何有错误或不够清晰的表达。可以在下面评论区评论,也可以邮件至 tuyrk@qq.com
文章标题:352-细说Java多线程之内存可见性
文章字数:3.4k
本文作者:神秘的小岛岛
发布时间:2019-01-05, 17:00:16
最后更新:2019-11-07, 15:31:32
原始链接:https://www.tuyrk.cn/imooc/352-volatile/版权声明: "署名-非商用-相同方式共享 4.0" 转载请保留原文链接及作者。