Java多线程与并发_volatile关键字详解

仅仅活着是不够的&＃xff0c;还需要有阳光、自由&＃xff0c;和一点花的芬芳

一、volatile关键字

volatile是JVM提供的一种轻量级的同步机制&＃xff0c;特性&＃xff1a;

1.保证内存可见性

2.不保证原子性

3.防止指令重排序

二、JMM(Java Memory Model)

Java内存模型中规定了所有的变量都存储在主内存中&＃xff08;如虚拟机物理内存中的一部分&＃xff09;&＃xff0c;每条线程还有自己的工作内存&＃xff08;如CPU中的高速缓存&＃xff09;&＃xff0c;线程的工作内存中保存了该线程使用到的变量到主内存的副本拷贝&＃xff0c;线程对变量的所有操作&＃xff08;读取、赋值&＃xff09;都必须在工作内存中进行&＃xff0c;而不能直接读写主内存中的变量。不同线程之间无法直接访问对方工作内存中的变量&＃xff0c;线程间变量值的传递均需要通过主内存来完成&＃xff0c;线程、主内存和工作内存的交互关系如下图所示&＃xff1a;

三、验证

1.验证volatile的可见性

1.1 假如 int num &＃061; 0&＃xff1b; num变量之前根本没有添加volatile关键字修饰,没有可见性
1.2 添加了volatile&＃xff0c;可以解决可见性问题

MyData类

class MyData {
volatile int num &＃061; 0;
public void addT060() {
this.num &＃061; 60;
}
}


内存可见性验证&＃xff0c;其中两个线程分别为AAA线程和main线程

//volatile可以保证可见性&＃xff0c;及时通知其它线程&＃xff0c;主内存的值已经被修改
&＃064;Test
public void seeOkByVolatile() {
MyData myData &＃061; new MyData();//资源类
new Thread(() -> {
System.out.println(Thread.currentThread().getName() &＃043; "\t come in");
//暂停一会线程
try{
TimeUnit.SECONDS.sleep(3);
}catch (InterruptedException e) {
e.printStackTrace();
}
myData.addT060();
System.out.println(Thread.currentThread().getName() &＃043; "\t update num value: " &＃043; myData.num);
},"AAA").start();
//第2个线程是我们的main线程
while (myData.num &＃061;&＃061; 0) {
//main线程就一直在这里等待循环&＃xff0c;直到num值不再等于0.
}
System.out.println(Thread.currentThread().getName() &＃043; "\t mission is over,main get num value: " &＃043; myData.num );
}


对num变量加volatile修饰后结果

AAA come in
AAA update num value: 60
main 我能见到AAA线程对num修改的结果啦,main get num value: 60
Process finished with exit code 0


2.验证volatile不保证原子性

2.1 原子性指的是什么意思&＃xff1f;
不可分割&＃xff0c;完整性&＃xff0c;也即某个线程正在做某个具体任务时&＃xff0c;中间不可以被加塞或者被分割。需要整体完整。要么同时成功&＃xff0c;要么同时失败。
2.2 volatile不保证原子性的案例演示
2.3 为什么不保证原子性&＃xff1f;
2.4 如何保证原子性
加sync
使用我们juc下的AtomicInteger (底层实现CAS)

给MyData类加addPlusPlus()方法

class MyData {//MyData.java &＃061;&＃061;&＃061;> MyData.class &＃061;&＃061;&＃061;> JVM字节码
int num &＃061; 0;
public void addT060() {
this.num &＃061; 60;
}
//请注意&＃xff0c;此时num前面是加了关键字修饰的,volatile不保证原子性
public void addPlusPlus() {
num&＃043;&＃043;;
}
}


2.2 volatile不保证原子性的案例演示

num&＃043;&＃043;在多线程操作的情况下不保证原子性的

创建20个线程并行执行num&＃043;&＃043;操作2000次&＃xff0c;多次测试&＃xff0c;结果不为40000

public static void main(String[] args) {
MyData myData &＃061; new MyData();
for (int i &＃061; 1; i <&＃061; 20; i&＃043;&＃043; ) {
new Thread(() -> {
for (int j &＃061; 1; j <&＃061; 2000; j&＃043;&＃043;) {
myData.addPlusPlus();
}
},String.valueOf(i)).start();
}
//需要等待上面20个线程都全部计算完成后&＃xff0c;再用main线程取得最终的结果值看是多少&＃xff1f;
while(Thread.activeCount() > 2) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName() &＃043; "\t finally num value:" &＃043; myData.num);
}


结果&＃xff1a;数值小于40000&＃xff0c;出现写值丢失的情况

main finally num value:38480
Process finished with exit code 0


2.3 为什么不保证原子性&＃xff1f;

因为当线程A对num&＃043;&＃043;操作从自己的工作内存刷新到主内存时&＃xff0c;还未通知到其他线程主内存变量有更新的瞬间&＃xff0c;其他线程对num变量的操作结果也对主内存进行了刷新&＃xff0c;从而导致了写值丢失的情况

num&＃043;&＃043;通过汇编指令分析&＃xff0c;通过javap反编译得到如下汇编指令

class com.slx.juc.MyData {
volatile int num;
com.slx.juc.MyData();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."":()V
4: aload_0
5: iconst_0
6: putfield #2 // Field num:I
9: return
public void addT060();
Code:
0: aload_0
1: bipush 60
3: putfield #2 // Field num:I
6: return
public void addPlusPlus();
Code:
0: aload_0
1: dup
2: getfield #2 // Field num:I
5: iconst_1
6: iadd
7: putfield #2 // Field num:I
10: return
}


可见num&＃043;&＃043;被拆分成了3个步骤,简称&＃xff1a;读-改-写

1. 执行getfield拿到原始num&＃xff1b;


2. 执行iadd进行加1操作&＃xff1b;


3. 执行putfield写把累加后的值写回

2.4 如何保证原子性

加sync
使用我们juc下的AtomicInteger (底层实现CAS)


MyData类中添加原子类操作方法

AtomicInteger atomicInteger &＃061; new AtomicInteger();
public void addMyAtomic() {
atomicInteger.getAndIncrement();
}


调用该方法打印结果

public static void main(String[] args) {
MyData myData &＃061; new MyData();
for (int i &＃061; 1; i <&＃061; 20; i&＃043;&＃043; ) {
new Thread(() -> {
for (int j &＃061; 1; j <&＃061; 2000; j&＃043;&＃043;) {
myData.addMyAtomic();
}
},String.valueOf(i)).start();
}
//需要等待上面20个线程都全部计算完成后&＃xff0c;再用main线程取得最终的结果值看是多少&＃xff1f;
while(Thread.activeCount() > 2) {
Thread.yield();
}
System.out.println(Thread.currentThread().getName() &＃043; "\t AtomicInteger type ,finally num value:" &＃043; myData.atomicInteger);
}


测试结果为40000&＃xff0c;不会出现之前int类型的丢失值的情况

main AtomicInteger type ,finally num value:40000
Process finished with exit code 0


本文地址：https://blog.csdn.net/for_my_life/article/details/89260698