}
System.out.println(Thread.currentThread().getName()+"\t number = " + myData.number);
}
}
class MyData{
// 没有用volatile来修饰
int number = 0;
public void addTo60(){
this.number = 60;
}
}
效果如下:
通过volatile
来解决此问题
我们可以发现当变量被volatile
修饰的时候,在子线程的工作内存中的变量被修改后其他线程中对应的变量是可以立马知道的。这就是我们讲的可见性
==================================================================
原子性是不可分割
,完整性
,也即某个线程正在做某个具体业务时,中间不可以被加塞或者分割,需要整体完成,要么同时成功,要么同时失败.
volatile是不支持
原子性的,接下来我们可以验证下。
package com.dpb.spring.aop.demo;
import java.util.concurrent.TimeUnit;
/**
- 可见性问题分析
*/
public class VolatileDemo2 {
public static void main(String[] args){
final MyData2 myData = new MyData2();
for (int i = 1; i <= 20 ; i++) {
new Thread(()->{
for (int j = 1; j <= 1000 ; j++) {
myData.addPlusPlus();
}
},String.valueOf(i)).start();
}
// 等待子线程执行完成
while(Thread.activeCount() > 2){
Thread.yield();
}
// 在主线程中获取统计的信息值
System.out.println(Thread.currentThread().getName()+"\t finnally number value: "+myData.number);
}
}
class MyData2{
// 操作的变量被volatile修饰了
volatile int number = 0;
public void addPlusPlus(){
number++;
}
}
执行的效果
根据正常的逻辑在开启的20个子线程,每个执行1000遍累加,得到的结果应该是20000,但是我们发现运行的结果大概率会比我们期望的要小,而且变量也已经被volatile修饰了。说明并没有满足我们要求的原子性。这种情况下我们要保证操作的原子性,我们有两个选择
-
通过synchronized来实现
-
通过
JUC
下的AtomicInteger
来实现
synchronized的实现是重量级的,影响并发的效率,所以我们通过AtomicInteger来实现。
package com.dpb.spring.aop.demo;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
- 可见性问题分析
*/
public class VolatileDemo2 {
public static void main(String[] args){
final MyData2 myData = new MyData2();
for (int i = 1; i <= 20 ; i++) {
new Thread(()->{
for (int j = 1; j <= 1000 ; j++) {
myData.addPlusPlus();
myData.addAtomicPlus();
}
},String.valueOf(i)).start();
}
// 等待子线程执行完成
while(Thread.activeCount() > 2){
Thread.yield();
}
// 在主线程中获取统计的信息值
System.out.println(Thread.currentThread().getName()+"\t finnally number value: "+myData.number);
System.out.println(Thread.currentThread().getName()+"\t finnally number value: "+myData.atomicInteger.get());
}
}
class MyData2{
// 操作的变量被volatile修饰了
volatile int number = 0;
// AtomicInteger 来保证操作的原子性
AtomicInteger atomicInteger = new AtomicInteger();
public void addPlusPlus(){
number++;
}
public void addAtomicPlus(){
atomicInteger.getAndIncrement();
}
}
效果:
注意
:通过效果发现AtomicInteger
在多线程环境下处理的数据和我们期望的结果是一致的都是20000
.说明实现的操作的原子性。
==================================================================
计算机在执行程序时,为了提高性能,编译器和处理器常常会对指令做重排,一般分一下3种:
- 单线程环境里面确保程序最终执行结果和代码顺序执行的结果一致。
最后
在面试前我整理归纳了一些面试学习资料,文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例
由于篇幅限制,文档的详解资料太全面,细节内容太多,所以只把部分知识点截图出来粗略的介绍,每个小节点里面都有更细化的内容!
大家看完有什么不懂的可以在下方留言讨论也可以关注。
觉得文章对你有帮助的话记得关注我点个赞支持一下!
里面确保程序最终执行结果和代码顺序执行的结果一致。
最后
在面试前我整理归纳了一些面试学习资料,文中结合我的朋友同学面试美团滴滴这类大厂的资料及案例
[外链图片转存中…(img-1bCM11Jh-1714139375931)]
[外链图片转存中…(img-dzL6FHAp-1714139375932)]
由于篇幅限制,文档的详解资料太全面,细节内容太多,所以只把部分知识点截图出来粗略的介绍,每个小节点里面都有更细化的内容!
大家看完有什么不懂的可以在下方留言讨论也可以关注。
觉得文章对你有帮助的话记得关注我点个赞支持一下!