并发二

一、volatile 原理

线程频繁对主内存读写操作，会产生性能问题，因此线程都有一个自己的工作内存。读写操作都会在工作内存中执行，而不会到主内存中。

volatile 的底层实现原理是内存屏障：

• 对 volatile 变量的写指令后会加入写屏障
• 对 volatile 变量的读指令前会加入读屏障

1.1 保证可见性

写屏障（sfence）保证在该屏障之前的，对共享变量的改动，都同步到主存当中

public void actor2(I_Result r) {
num = 2;
ready = true; // ready是被volatile修饰的 ，赋值带写屏障
// 写屏障
}

而读屏障（lfence）保证在该屏障之后，对共享变量的读取，加载的是主存中最新数据

1. public void actor1(I_Result r) {
// 读屏障
// ready是被volatile修饰的 ，读取值带读屏障
if(ready) {
r.r1 = num + num;
} else {
r.r1 = 1;
}
}

​

1.2保证有序性

• 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后

public void actor2(I_Result r) {
num = 2;
ready = true; // ready是被volatile修饰的 ， 赋值带写屏障
// 写屏障
}

• 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前 ​x 1public void actor1(I_Result r) {2// 读屏障3// ready是被volatile修饰的 ，读取值带读屏障4if(ready) {5r.r1 = num + num;6} else {7r.r1 = 1;8}9}​
• 而有序性的保证也只是保证了本线程内相关代码不被重排序

一句话：volatile 能保证可见性和有序性，但无法保证原子性。monitor则可以同时保证这三个

以上的实现特点是： 0. 懒惰实例化
1. 首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁
2. 有隐含的，但很关键的一点：第一个 if 使用了 INSTANCE 变量，是在同步块之外

但在多线程环境下，上面的代码是有问题的，getInstance 方法对应的字节码为： ```
0: getstatic #2 // Field INSTANCE:Lcn/itcast/n5/Singleton;
3: ifnonnull 37
// ldc是获得类对象
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

1.3 happens-before规则

下面说的变量都是指成员变量或静态成员变量

1）线程解锁 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();


2）线程对 volatile 变量的写，对接下来其它线程对该变量的读可见

volatile static int x;
new Thread(()->{
x = 10;
},t1).start();
new Thread(()->{
System.out.println(x);
},t2).start();


3）线程 start 前对变量的写，对该线程开始后对该变量的读可见

static int x;
x = 10;
new Thread(()->{
System.out.println(x);
},t2).start();

4）线程结束前对变量的写，对其它线程得知它结束后的读可见（比如其它线程调用 t1.isAlive() 或 t1.join()等待它结束）static int x;
Thread t1 = new Thread(()->{
x = 10;
},t1);
t1.start();
t1.join();
System.out.println(x);

5）线程 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);
}

6）对变量默认值（0，false，null）的写，对其它线程对该变量的读可见

7）具有传递性，如果 x hb-> y 并且 y hb-> z 那么有 x hb-> z ，配合 volatile 的防指令重排，有下面的例子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();