1. 共享模型之内存
1.1 Java 内存模型
JMM 即 Java Memory Model，它定义了主存、工作内存抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、CPU 指令优化等。
JMM 体现在以下几个方面
- 原子性 - 保证指令不会受到线程上下文切换的影响 //处理器基于总线锁定/缓存锁定实现原子性
- 可见性 - 保证指令不会受 cpu 缓存的影响
- 有序性 - 保证指令不会受 cpu 指令并行优化的影响
1.2 可见性
退不出的循环
先来看一个现象，main 线程对 run 变量的修改对于 t 线程不可见，导致了 t 线程无法停止：
static boolean run = true;
public static void main(String[] args) throws InterruptedException {
Thread t = new Thread(()->{
while(run){
// ....
}
});
t.start();
sleep( 1 );//sleep一段时间才能看到效果，因为jvm在执行一定次数后会对代码进行优化
run = false; // 线程t不会如预想的停下来
}
为什么呢？分析一下：
- 初始状态， t 线程刚开始从主内存读取了 run 的值到工作内存。
- 因为 t 线程要频繁从主内存中读取 run 的值，JIT 编译器会将 run 的值缓存至自己工作内存中的高速缓存中，减少对主存中 run 的访问，提高效率
- 1 秒之后，main 线程修改了 run 的值，并同步至主存，而 t 是从自己工作内存中的高速缓存中读取这个变量的值，结果永远是旧值
解决方法
volatile（易变关键字）
它可以用来修饰成员变量和静态成员变量，他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存
1.2.1可见性 vs 原子性
前面例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对 volatile 变量的修改对另一个线程可见， 不能保证原子性，仅用在一个写线程，多个读线程的情况： 上例从字节码理解是这样的：
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
getstatic run // 线程 t 获取 run true
putstatic run // 线程 main 修改 run 为 false， 仅此一次
getstatic run // 线程 t 获取 run false
比较一下之前我们将线程安全时举的例子：两个线程一个 i++ 一个 i-- ，只能保证看到最新值，不能解决指令交错
// 假设i的初始值为 0
getstatic i // 线程2-获取静态变量i的值 线程内i=0
getstatic i // 线程1-获取静态变量i的值 线程内i=0
iconst_1 // 线程1-准备常量 1
iadd // 线程1-自增 线程内i=1
putstatic i // 线程1-将修改后的值存入静态变量i 静态变量i=1
iconst_1 // 线程2-准备常量 1
isub // 线程2-自减 线程内i=-1
putstatic i // 线程2-将修改后的值存入静态变量i 静态变量i=-1
注意
synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是synchronized 是属于重量级操作，性能相对更低
如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了，因为println()方法内用了synchronized。
1.2.4模式之 Balking
Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回
实现：
public class MonitorService {
// 用来表示是否已经有线程已经在执行启动了
private volatile boolean starting;
public void start() {
log.info("尝试启动监控线程...");
synchronized (this) {
if (starting) {
return;
}
starting = true;
}
// 真正启动监控线程...
}
可以用来实现单例
public final class Singleton {
private Singleton() {
}
private static Singleton INSTANCE = null;
public static synchronized Singleton getInstance() {
if (INSTANCE != null) {
return INSTANCE;
}
INSTANCE = new Singleton();
return INSTANCE;
}
}
保护性暂停是当条件不满足是，让一个线程等待另一个线程的结果。
1.3 有序性
JVM 会在不影响正确性的前提下，可以调整语句的执行顺序。
static int i;
static int j;
// 在某个线程内执行如下赋值操作
i = ...;
j = ...;
可以看到，至于是先执行 i 还是 先执行 j ，对最终的结果不会产生影响。所以，上面代码真正执行时，既可以是
i = ...;//i先执行
j = ...;
也可以是
j = ...;
i = ...;
这种特性称之为『指令重排』，单线程下由于遵循as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序，也就不会影响结果的正确性，但在多线程下，『指令重排』可能会影响正确性。为什么要有重排指令这项优化呢？主要是为了充分利用CPU执行的性能。
1.3.1原理之指令级并行
诡异的结果
int num = 0 ;
boolean ready = false;
// 线程 1 执行此方法
public void actor1(I_Result r) {
if(ready) {
r.r1 = num + num;
} else {
r.r1 = 1 ;
}
}
// 线程 2 执行此方法
public void actor2(I_Result r) {
num = 2 ;
ready = true;
}
I_Result 是一个对象，有一个属性 r1 用来保存结果，问，可能的结果有几种？
可以分以下几种情况分析：
情况 1 ：线程 1 先执行，这时 ready = false，所以进入 else 分支结果为 1
情况 2 ：线程 2 先执行 num = 2，但没来得及执行 ready = true，线程 1 执行，还是进入 else 分支，结果为 1
情况 3 ：线程 2 执行到 ready = true，线程 1 执行，这回进入 if 分支，结果为 4 （因为 num 已经执行过了）
所以，答案是2种1和4。然而这实际上是错的，因为还有一种可能是0。
这种情况下是：线程 2 执行 ready = true，切换到线程 1 ，进入 if 分支，相加为 0 ，再切回线程 2 执行 num = 2。
这种现象叫做指令重排，是 JIT 编译器在运行时的一些优化，这个现象需要通过大量测试才能复现：
借助 java 并发压测工具 jcstress https://wiki.openjdk.java.net/display/CodeTools/jcstress
mvn archetype:generate -DinteractiveMode=false -DarchetypeGroupId=org.openjdk.jcstress -
DarchetypeArtifactId=jcstress-java-test-archetype -DarchetypeVersion=0.5 -DgroupId=cn.itcast -
DartifactId=ordering -Dversion=1.0
创建 maven 项目，提供如下测试类
@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
int num = 0 ;
boolean ready = false;
@Actor
public void actor1(I_Result r) {
if(ready) {
r.r1 = num + num;
} else {
r.r1 = 1 ;
}
}
@Actor
public void actor2(I_Result r) {
num = 2 ;
ready = true;
}
}
执行
mvn clean install
java -jar target/jcstress.jar
会输出我们感兴趣的结果，摘录其中一次结果：
*** INTERESTING tests
Some interesting behaviors observed. This is for the plain curiosity.
2 matching test results.
[OK] test.ConcurrencyTest
(JVM args: [-XX:-TieredCompilation])
Observed state Occurrences Expectation Interpretation
0 1,729 ACCEPTABLE_INTERESTING !!!!
1 42,617,915 ACCEPTABLE ok
4 5,146,627 ACCEPTABLE ok
以看到，出现结果为 0 的情况有 1729次，虽然次数相对很少，但毕竟是出现了。
解决方法：
volatile 修饰的变量，可以禁用指令重排 :，结果就是1或者4
@JCStressTest
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "!!!!")
@State
public class ConcurrencyTest {
int num = 0 ;
volatile boolean ready = false;
@Actor
public void actor1(I_Result r) {
if(ready) {
r.r1 = num + num;
} else {
r.r1 = 1 ;
}
}
@Actor
public void actor2(I_Result r) {
num = 2 ;
ready = true;
}
}
结果为：
*** INTERESTING tests
Some interesting behaviors observed. This is for the plain curiosity.
0 matching test results.
1.3.2原理之 volatile
volatile 的底层实现原理是内存屏障，Memory Barrier（Memory Fence）
- 对 volatile 变量的写指令前后会加入写屏障
- 对 volatile 变量的读指令后会加入读屏障
1.3.2.1保证可见性
- 写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中（注意，volatile不止会将被修饰的变量的改动同步到主内存中，也会将该变量之前的变量(之后的无效)改动同步到内存中，也就是该线程对应的本地内存变量值刷新到主内存中）
public void actor2(I_Result r) {
num = 2; //第一个操作 普通写
ready = true; // ready 是 volatile 第二个操作volatile写 赋值带写屏障
// 写屏障
}
- 而读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据(对于读取被volatile修饰的变量之前的变量值，一样读到的是最新的值，注意注意！！！！这里是指读volatile修饰的变量，如果是单纯的读普通变量（例子中不读ready，只读num）仍有可能读取的是缓存值)
public void actor1(I_Result r) {
// 读屏障
// ready 是 volatile 读取值带读屏障
if(ready) {
r.r1 = num + num;
} else {
r.r1 = 1;
}
}
注意：
sychronized只能保证有序性不能禁止指令重排，sychronized内的代码还是可以指令重排的。
对于单线程的代码来说，就算发生了指令重排，因为as-if-serial语义，它还是可以保证结果的正确性，也就保证了有序性。
虽然单线程无问题，但多线程可能会因为指令重排出现bug。
比如同步代码块中某个变量在代码块外也有读写，典型的例子就是duble check lock的单例模式。
第一个if判断实例是否为null的代码不在sychronized的代码块中，脱离了控制，当同步代码块内发生指令重排时，同步代码块外读取实例变量就可能会发生错误，也就导致有序性的问题
1.3.2.2保证有序性
- 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
public void actor2(I_Result r) {
num = 2;
ready = true; // ready 是 volatile 赋值带写屏障
// 写屏障
}
- 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
public void actor1(I_Result r) {
// 读屏障
// ready 是 volatile 读取值带读屏障
if(ready) {
r.r1 = num + num;
} else {
r.r1 = 1;
}
}
还是那句话，不能解决多线程之间的指令交错：
- 写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证另一个线程的读跑到它前面去（i++和i–的原子性）
- 而有序性的保证也只是保证了本线程内相关代码不被重排序(线程间的指令由cpu调度器决定顺序，比如上面的例子结果还是可能为1或者4)
1.3.2.3单例模式的问题
以著名的 double-checked locking 单例模式为例
public final class Singleton {
private Singleton() { }
private static Singleton INSTANCE = null;
public static Singleton getInstance() {
if(INSTANCE == null) { // t2
// 首次访问会同步，而之后的使用没有 synchronized
synchronized(Singleton.class) {
if (INSTANCE == null) { // t1
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
以上的实现特点是：
- 懒惰实例化
- 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁
- 有隐含的，但很关键的一点：第一个 if 使用了 INSTANCE 变量，是在同步块之外
但在多线程环境下，上面的代码是有问题的，getInstance 方法对应的字节码为：
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
27: aload_0
28: monitorexit
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn
其中
- 17 表示创建对象，将对象引用入栈 // new Singleton
- 20 表示复制一份对象引用 // 引用地址
- 21 表示利用一个对象引用，调用构造方法
- 24 表示利用一个对象引用，赋值给 static INSTANCE
也许 jvm 会优化为：先执行 24，再执行 21。如果两个线程 t1，t2 按如下时间序列执行：
关键在于 0: getstatic 这行代码在 monitor 控制之外，它就像之前举例中不守规则的人，可以越过 monitor 读取INSTANCE 变量的值
这时 t1 还未完全将构造方法执行完毕，如果在构造方法中要执行很多初始化操作，那么 t2 拿到的是将是一个未初始化完毕的单例(分配了地址却没有初始化)
解决办法是对 INSTANCE 使用 volatile 修饰即可，可以禁用指令重排，但要注意在 JDK 5 以上的版本的 volatile 才会真正有效
1.3.2.4单例问题解决
public final class Singleton {
private Singleton() { }//不能少
private static volatile Singleton INSTANCE = null;
public static Singleton getInstance() {
// 实例没创建，才会进入内部的 synchronized代码块
if (INSTANCE == null) {
synchronized (Singleton.class) { // t2
// 也许有其它线程已经创建实例，所以再判断一次
if (INSTANCE == null) { // t1
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
字节码上看不出来 volatile 指令的效果
// -------------------------------------> 加入对 INSTANCE 变量的读屏障
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
6: ldc #3 // class cn/itcast/n5/Singleton
8: dup
9: astore_0
10: monitorenter -----------------------> 保证原子性、可见性
11: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
14: ifnonnull 27
17: new #3 // class cn/itcast/n5/Singleton
20: dup
21: invokespecial #4 // Method "<init>":()V
24: putstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
// -------------------------------------> 加入对 INSTANCE 变量的写屏障
27: aload_0
28: monitorexit ------------------------> 保证原子性、可见性
29: goto 37
32: astore_1
33: aload_0
34: monitorexit
35: aload_1
36: athrow
37: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
40: areturn
如上面的注释内容所示，读写 volatile 变量时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：
- 可见性
- 写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
- 而读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据
- 有序性
- 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
- 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
- 更底层是读写变量时使用 lock 指令来多核 CPU 之间的可见性与有序性
1.3.3happens-before
happens-before 规定了对共享变量的写操作对其它线程的读操作可见需要满足的条件，它是可见性与有序性的一套规则总结，抛开以下 happens-before 规则，JMM 并不能保证一个线程对共享变量的写，对于其它线程对该共享变量的读可见。（happen-before规则，并不意味着前一个操作在后一个操作之前执行，只是要求前一个操作的结果对后一个操作可见，编译器和处理器不会保证那些不影响执行结果的happen-before规则）
- 线程解锁 m 之前对变量的写，对于接下来对 m 加锁的其它线程对该变量的读可见
static int x;
static Object m = new Object();
new Thread(()->{
synchronized(m) {
x = 10 ;
}
},"t1").start();
new Thread(()->{
synchronized(m) {
System.out.println(x);
}
},"t2").start();
- 线程对 volatile 变量的写，对接下来其它线程对该变量的读可见
volatile static int x;
new Thread(()->{
x = 10 ;
},"t1").start();
new Thread(()->{
System.out.println(x);
},"t2").start();
- 线程 start 前对变量的写，对该线程开始后对该变量的读可见
static int x;
new Thread(()->{
System.out.println(x);
},"t2").start();
- 线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或 t1.join()等待它结束）
static int x;
Thread t1 = new Thread(()->{
x = 10 ;
},"t1");
t1.start();
t1.join();
System.out.println(x);
- 线程 t1 打断 t2（interrupt）前对变量的写，对于其他线程得知 t2 被打断后对变量的读可见（通过t2.interrupted 或 t2.isInterrupted）
static int x;
public static void main(String[] args) {
Thread t2 = new Thread(()->{
while(true) {
if(Thread.currentThread().isInterrupted()) {
System.out.println(x);
break;
}
}
},"t2");
t2.start();
new Thread(()->{
sleep(1);
x = 10;
t2.interrupt();
},"t1").start();
while(!t2.isInterrupted()) {
Thread.yield();
}
System.out.println(x);
}
- 对变量默认值（ 0 ，false，null）的写，对其它线程对该变量的读可见
变量都是指成员变量或静态成员变量 - 具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z，配合 volatile 的防指令重排，有下面的例子
hb:happenbefore
volatile static int x;
static int y;
new Thread(()->{
y = 10;
x = 20;
},"t1").start();
new Thread(()->{
// x=20 对 t2 可见, 同时 y=10 也对 t2 可见
System.out.println(x);
},"t2").start();
总结来讲就是：
- 程序顺序规则
- 监视器锁规则
- volatile变量规则
- 传递性
1.3.4问题
1.3.4.1balking 模式练习
希望 doInit() 方法仅被调用一次，下面的实现是否有问题，为什么？
public class TestVolatile {
volatile boolean initialized = false;
void init() {
if (initialized) {
return;
}
doInit();
initialized = true;
}
private void doInit() {
}
}
有，无法保证原子性，多线程下会有bug，需要用sychronized解决。
1.3.4.2线程安全单例习题
单例模式有很多实现方法，饿汉、懒汉、静态内部类、枚举类，试分析每种实现下获取单例对象（即调用getInstance）时的线程安全，并思考注释中的问题
- 饿汉式：类加载就会导致该单实例对象被创建
- 懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建
实现 1 ：
// 问题 1 ：为什么加 final //防止被子类重写方法
// 问题 2 ：如果实现了序列化接口, 还要做什么来防止反序列化破坏单例 //用下面的readResolve方法
public final class Singleton implements Serializable {
// 问题 3 ：为什么设置为私有? 是否能防止反射创建新的实例?
//不让外部获取构造方法，不能阻止反射获取实例,只有枚举能阻止
private Singleton() {}
// 问题 4 ：这样初始化是否能保证单例对象创建时的线程安全?//是的，类的加载过程由JVM保证线程安全
private static final Singleton INSTANCE = new Singleton();
// 问题 5 ：为什么提供静态方法而不是直接将 INSTANCE 设置为 public//更好的封装性
public static Singleton getInstance() {
return INSTANCE;
}
public Object readResolve() {//解决序列化破坏单例问题
return INSTANCE;
}
}
序列化破坏单例原理文章：
https://www.cnblogs.com/kexianting/p/8977990.html
https://blog.csdn.net/wenbin516/article/details/85739015反射破坏单例
https://www.freesion.com/article/39111140051
实现 2 ：
// 问题 1 ：枚举单例是如何限制实例个数的//他是枚举类中一个静态成员变量
// 问题 2 ：枚举单例在创建时是否有并发问题//不会，在类加载时完成
// 问题 3 ：枚举单例能否被反射破坏单例//反射newInstance时会判断是否为eunm,如果是抛异常
// 问题 4 ：枚举单例能否被反序列化破坏单例//不能，枚举的反序列化是通过valueof方法，而不是反射
// 问题 5 ：枚举单例属于懒汉式还是饿汉式//饿汉式
// 问题 6 ：枚举单例如果希望加入一些单例创建时的初始化逻辑该如何做//写一个构造方法
enum Singleton {
INSTANCE;
}
实现 3 ：懒汉式
public final class Singleton {
private Singleton() { }
private static Singleton INSTANCE = null;
// 分析这里的线程安全, 并说明有什么缺点//锁的粒度太大
public static synchronized Singleton getInstance() {
if( INSTANCE != null ){
return INSTANCE;
}
INSTANCE = new Singleton();
return INSTANCE;
}
}
实现 4 ：DCL
public final class Singleton {
private Singleton() { }
// 问题 1 ：解释为什么要加 volatile?//禁止创建对象时指令重排
private static volatile Singleton INSTANCE = null;
// 问题 2 ：对比实现3, 说出这样做的意义//粒度更小，效率会更高
public static Singleton getInstance() {
if (INSTANCE != null) {//这里不需要锁
return INSTANCE;
}
synchronized (Singleton.class) {
// 问题 3 ：为什么还要在这里加为空判断, 之前不是判断过了吗//防止多线程同时创建
if (INSTANCE != null) { // t2
return INSTANCE;
}
INSTANCE = new Singleton();
return INSTANCE;
}
}
}
实现 5 ：静态内部类
public final class Singleton {
private Singleton() { }
// 问题 1 ：属于懒汉式还是饿汉式//饿汉式 类加载在类用到时才加载
private static class LazyHolder {
static final Singleton INSTANCE = new Singleton();
}
// 问题 2 ：在创建时是否有并发问题 没有 JVM自己加载时解决
public static Singleton getInstance() {
return LazyHolder.INSTANCE;
}
}
注：内容是从自己语雀上迁移过来的，内容整理自视频课程深入学习并发编程。
扫一扫
755
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
