Java 并发编程中篇 -（JMM、CAS 原理、Volatile 原理）

最新推荐文章于 2024-06-09 09:31:53 发布

置顶

CodeAli

最新推荐文章于 2024-06-09 09:31:53 发布

阅读量7.5k

点赞数 19

分类专栏： Java并发编程文章标签： java 多线程并发编程

本文链接：https://blog.youkuaiyun.com/weixin_50280576/article/details/113532093

版权

并发编程已完结，章节如下：
Java 并发编程上篇 -（Synchronized 原理、LockSupport 原理、ReentrantLock 原理）
Java 并发编程中篇 -（JMM、CAS 原理、Volatile 原理）
Java 并发编程下篇 -（线程池）
Java 并发编程下篇 -（JUC、AQS 源码、ReentrantLock 源码）

四、共享模型之内存

1、Java 内存模型（JMM）

JMM 即 Java Memory Model，它定义了主存（共享内存）、工作内存（线程私有）抽象概念，底层对应着 CPU 寄存器、缓存、硬件内存、 CPU 指令优化等。
JMM 体现在以下几个方面

原子性 - 保证指令不会受到线程上下文切换的影响
可见性 - 保证指令不会受 cpu 缓存的影响
有序性 - 保证指令不会受 cpu 指令并行优化的影响

2、可见性

1）退不出的循环

首先看一段代码：

public static boolean run = true;

    public static void main(String[] args) {
   

        Thread t1 = new Thread(() -> {
   
            while(run) {
   

            }
        }, "t1");

        t1.start();

        try {
   
            Thread.sleep(1000);
        } catch (InterruptedException e) {
   
            e.printStackTrace();
        }
        log.info("t1 Stop");
        run = false;
    }

首先 t1 线程运行，然后过一秒，主线程设置 run 的值为 false，想让 t1 线程停止下来，但是 t1 线程并没有停，分析如下图：
在这里插入图片描述
解决方法

使用 volatile （易变关键字）
它可以用来修饰成员变量和静态成员变量（放在主存中的变量），他可以避免线程从自己的工作缓存中查找变量的值，必须到主存中获取它的值，线程操作 volatile 变量都是直接操作主存

 public static volatile boolean run = true; // 保证内存的可见性

2）可见性与原子性

上面例子体现的实际就是可见性，它保证的是在多个线程之间，一个线程对volatile 变量的修改对另一个线程可见，不能保证原子性，仅用在一个写线程，多个读线程的情况。

注意 synchronized 语句块既可以保证代码块的原子性，也同时保证代码块内变量的可见性。但缺点是 synchronized 是属于重量级操作，性能相对更低。
如果在前面示例的死循环中加入 System.out.println() 会发现即使不加 volatile 修饰符，线程 t 也能正确看到对 run 变量的修改了，想一想为什么？
因为 printIn() 方法使用了 synchronized 同步代码块，可以保证原子性与可见性，它是 PrintStream 类的方法。

3）模式之两阶段终止

使用 volatile 关键字来实现两阶段终止模式。

public class Code_02_Test {
   
	public static void main(String[] args) throws InterruptedException {
   
		Monitor monitor = new Monitor();
		monitor.start();
		Thread.sleep(3500);
		monitor.stop();
	}
}

class Monitor {
   

	Thread monitor;
	// 设置标记，用于判断是否被终止了
	private volatile boolean stop = false;
	/**
	 * 启动监控器线程
	 */
	public void start() {
   
		// 设置线控器线程，用于监控线程状态
		monitor = new Thread() {
   
			@Override
			public void run() {
   
				// 开始不停的监控
				while (true) {
   
					if(stop) {
   
						System.out.println("处理后续任务");
						break;
					}
					System.out.println("监控器运行中...");
					try {
   
						// 线程休眠
						Thread.sleep(1000);
					} catch (InterruptedException e) {
   
						System.out.println("被打断了");
					}
				}
			}
		};
		monitor.start();
	}

	/**
	 * 	用于停止监控器线程
	 */
	public void stop() {
   
		// 修改标记
		stop = true;
		// 打断线程
		monitor.interrupt();        
	}
}

4）模式之 Balking

Balking （犹豫）模式用在一个线程发现另一个线程或本线程已经做了某一件相同的事，那么本线程就无需再做了，直接结束返回，有点类似单例。

用一个标记来判断该任务是否已经被执行过了
需要避免线程安全问题
加锁的代码块要尽量的小，以保证性能

public class Code_03_Test {
   
	public static void main(String[] args) throws InterruptedException {
   
		Monitor monitor = new Monitor();
		monitor.start();
		monitor.start();
		Thread.sleep(3500);
		monitor.stop();
	}
}

class Monitor {
   

	Thread monitor;
	// 设置标记，用于判断是否被终止了
	private volatile boolean stop = false;
	// 设置标记，用于判断是否已经启动过了
	private boolean starting = false;
	/**
	 * 启动监控器线程
	 */
	public void start() {
   
		// 上锁，避免多线程运行时出现线程安全问题
		synchronized (this) {
   
			if (starting) {
   
				// 已被启动，直接返回
				return;
			}
			// 启动监视器，改变标记
			starting = true;
		}
		// 设置线控器线程，用于监控线程状态
		monitor = new Thread() {
   
			@Override
			public void run() {
   
				// 开始不停的监控
				while (true) {
   
					if(stop) {
   
						System.out.println("处理后续任务");
						break;
					}
					System.out.println("监控器运行中...");
					try {
   
						// 线程休眠
						Thread.sleep(1000);
					} catch (InterruptedException e) {
   
						System.out.println("被打断了");
					}
				}
			}
		};
		monitor.start();
	}

	/**
	 * 	用于停止监控器线程
	 */
	public void stop() {
   
		// 打断线程
		monitor.interrupt();
		stop = true;
	}
}

3、有序性

1）指令重排

首先看一个例子：

// 可以重排的例子 
int a = 10; 
int b = 20; 
System.out.println( a + b );

// 不能重排的例子 
int a = 10;
int b = a - 5;

指令重排简单来说可以，在程序结果不受影响的前提下，可以调整指令语句执行顺序。多线程下指令重排会影响正确性。

2）多线程下指令重排问题

首先看一段代码：

int num = 0;

// volatile 修饰的变量，可以禁用指令重排 volatile boolean ready = false; 可以防止变量之前的代码被重排序
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;
}

在多线程环境下，以上的代码 r1 的值有三种情况：
第一种：线程 2 先执行，然后线程 1 后执行，r1 的结果为 4
第二种：线程 1 先执行，然后线程 2 后执行，r1 的结果为 1
第三种：线程 2 先执行，但是发送了指令重排，num = 2 与 ready = true 这两行代码语序发生装换，

ready = true; // 前
num = 2; // 后

然后执行 ready = true 后，线程 1 运行了，那么 r1 的结果是为 0。

3）解决方法

volatile 修饰的变量，可以禁用指令重排，禁止的是加 volatile 关键字变量之前的代码重排序

4、volatile 原理

volatile 的底层实现原理是内存屏障，Memory Barrier（Memory Fence）
对 volatile 变量的写指令后会加入写屏障
对 volatile 变量的读指令前会加入读屏障

1）如何保证可见性

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

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

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

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

分析如图：
在这里插入图片描述

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;
 }
}

注意：volatile 不能解决指令交错
写屏障仅仅是保证之后的读能够读到最新的结果，但不能保证其它线程的读跑到它前面去。
而有序性的保证也只是保证了本线程内相关代码不被重排序

3）double-checked locking 问题

看如下代码：

	// 最开始的单例模式是这样的
    public final class Singleton {
   
        private Singleton() {
    }
        private static Singleton INSTANCE = null;
        public static Singleton getInstance() {
   
        // 首次访问会同步，而之后的使用不用进入synchronized
        synchronized(Singleton.class) {
   
        	if (INSTANCE == null) {
    // t1
        		INSTANCE = new Singleton();
            }
        }
            return INSTANCE;
        }
    }
// 但是上面的代码块的效率是有问题的，因为即使已经产生了单实例之后，之后调用了getInstance()方法之后还是会加锁，这会严重影响性能！因此就有了模式如下double-checked lockin：
    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;
        }
    }
//但是上面的if(INSTANCE == null)判断代码没有在同步代码块synchronized中，不能享有synchronized保证的原子性，可见性。所以

以上的实现特点是：

懒惰实例化
首次使用 getInstance() 才使用 synchronized 加锁，后续使用时无需加锁
有隐含的，但很关键的一点：第一个 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

其中

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 才会真正有效。

4）double-checked locking 解决

加volatile就行了。

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 变量操作（即 getstatic 操作和 putstatic 操作）时会加入内存屏障（Memory Barrier（Memory Fence）），保证下面两点：

可见性
1. 写屏障（sfence）保证在该屏障之前的 t1 对共享变量的改动，都同步到主存当中
2. 而读屏障（lfence）保证在该屏障之后 t2 对共享变量的读取，加载的是主存中最新数据
有序性
1. 写屏障会确保指令重排序时，不会将写屏障之前的代码排在写屏障之后
2. 读屏障会确保指令重排序时，不会将读屏障之后的代码排在读屏障之前
更底层是读写变量时使用 lock 指令来多核 CPU 之间的可见性与有序性

5、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()

最低0.47元/天解锁文章