标签：Thread 验证 myData 代码 volatile new changeData data public
一 . 可见性（visibility）
volatile关键字修饰的变量，如果值发生了改变，其他线程会立刻获取到，从而避免了出现脏读的情况。
1 public class TestVolatile {
2
3 public static void main(String[] args) {
4 MyData myData = new MyData();
5 new Thread(new Runnable() {
6 @Override
7 public void run() {
8 System.out.println("进入操作数据线程");
9 try {
10 Thread.sleep(1000);
11 } catch (InterruptedException e) {
12 e.printStackTrace();
13 }
14 //调用方法 赋值
15 myData.changeData();
16 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
17 }
18 },"操作数据线程").start();
19
20 // 主线程查看数据是否改了
21 while (myData.data == 0){
22
23 }
24 System.out.println("main线程结束");
25 }
26 }
27
28 class MyData{
29 int data = 0;
30 public void changeData(){
31 this.data = 2020;
32 }
33
34 }
如上面代码，有两个线程在操作MyDdata数据类，看一下执行结果
从结果可以看出，main线程一直就没有获取到数据更新信息，内存中的数据存储用图直观的看一下
main线程的内存线程并没获取到数据更新。
下面变量加上volatile的效果
1 public class TestVolatile {
2
3 public static void main(String[] args) {
4 MyData myData = new MyData();
5 new Thread(new Runnable() {
6 @Override
7 public void run() {
8 System.out.println("进入操作数据线程");
9 try {
10 Thread.sleep(1000);
11 } catch (InterruptedException e) {
12 e.printStackTrace();
13 }
14 //调用方法 赋值
15 myData.changeData();
16 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
17 }
18 },"操作数据线程").start();
19
20 // 主线程查看数据是否改了
21 while (myData.data == 0){
22
23 }
24 System.out.println("main线程结束");
25 }
26 }
27
28 class MyData{
29 volatile int data = 0;
30 public void changeData(){
31 this.data = 2020;
32 }
33
34 }
看一下执行结果
发现main方法已经获取到了数据更新。从而验证了volatile的可见性。
二 . 无法保证原子性
直接上代码
1 public class TestVolatile1 {
2
3 public static void main(String[] args) {
4 MyData1 myData = new MyData1();
5
6 new Thread(new Runnable() {
7 @Override
8 public void run() {
9 //调用方法 赋值
10 myData.changeData();
11 for(int i = 0;i < 9999;i++) {
12 myData.changeData();
13 }
14 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
15 }
16 },"线程1").start();
17
18
19 new Thread(new Runnable() {
20 @Override
21 public void run() {
22 //调用方法 赋值
23 myData.changeData();
24 for(int i = 0;i < 9999;i++) {
25 myData.changeData();
26 }
27 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
28 }
29 },"线程2").start();
30
31 new Thread(new Runnable() {
32 @Override
33 public void run() {
34 //调用方法 赋值
35 myData.changeData();
36 for(int i = 0;i < 9999;i++) {
37 myData.changeData();
38 }
39 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
40 }
41 },"线程3").start();
42
43 new Thread(new Runnable() {
44 @Override
45 public void run() {
46 //调用方法 赋值
47 myData.changeData();
48 for(int i = 0;i < 9999;i++) {
49 myData.changeData();
50 }
51 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
52 }
53 },"线程4").start();
54
55 while (Thread.activeCount() > 1) {
56 Thread.yield();
57 }
58
59 System.out.println("最终数值 ："+myData.data);
60 }
61 }
62
63 class MyData1{
64 volatile int data = 0;
65 public void changeData(){
66 data++;
67 }
68
69 }
咱们可以预测一下，如果正常的话，咱们应该得到的最终数据应该是40000 ，但结果如下
可以看到最终数据并不是我们想要的结果，多线程同时操作volatile修饰变量，无法保证数据的原子性。
那如何解决这个问题呢，用sychornized，可以处理，但是这是重量级锁，不推荐使用，还可以用 AtomicInteger 来处理这个情况实现代码如下
1 import java.util.concurrent.atomic.AtomicInteger;
2
3 public class TestVolatile1 {
4
5 public static void main(String[] args) {
6 MyData1 myData = new MyData1();
7
8 new Thread(new Runnable() {
9 @Override
10 public void run() {
11 //调用方法 赋值
12 myData.changeData();
13 for(int i = 0;i < 9999;i++) {
14 myData.changeData();
15 }
16 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
17 }
18 },"线程1").start();
19
20
21 new Thread(new Runnable() {
22 @Override
23 public void run() {
24 //调用方法 赋值
25 myData.changeData();
26 for(int i = 0;i < 9999;i++) {
27 myData.changeData();
28 }
29 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
30 }
31 },"线程2").start();
32
33 new Thread(new Runnable() {
34 @Override
35 public void run() {
36 //调用方法 赋值
37 myData.changeData();
38 for(int i = 0;i < 9999;i++) {
39 myData.changeData();
40 }
41 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
42 }
43 },"线程3").start();
44
45 new Thread(new Runnable() {
46 @Override
47 public void run() {
48 //调用方法 赋值
49 myData.changeData();
50 for(int i = 0;i < 9999;i++) {
51 myData.changeData();
52 }
53 System.out.println(Thread.currentThread().getName()+" : "+myData.data);
54 }
55 },"线程4").start();
56
57 while (Thread.activeCount() > 1) {
58 Thread.yield();
59 }
60
61 System.out.println("最终数值 ："+myData.data);
62 }
63 }
64
65 class MyData1{
66 AtomicInteger data = new AtomicInteger();
67 public void changeData(){
68 data.getAndIncrement();
69 }
70
71 }
执行结果如下
如此数据原子性问题便解决了。
三 . 指令重排
在JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对指令顺序进行重新排序。在不改变程序执行结果的前提下，优化程序的运行效率（不改变单线程下的程序执行结果）
看一段简单的代码
1 public class Data {
2
3 int a = 1; //步骤1
4 int b = 2; //步骤2
5 int c = a+b; //步骤3
6
7 }
单线程下，代码执行结果c的结果3，但是在执行的过程时候并不一定是1 ， 2，3这个执行顺序，在发生指令重排后，可能是2，1，3。单线程下对工程并没有什么影响。
但是如果是多线程，就会出现问题。查看如下方法
1 public class Volatile {
2
3 int a = 1;
4 boolean flag = false;
5
6 public void dosome1() {
7 a = 2;// 步骤1
8 flag = true; //步骤2
9 }
10
11 public void dosome2() {
12 if(flag){
13 int b = a+a; // 步骤3
14 }
15 }
16 }
上面的代码步骤3其实是两个步骤，为了好理解，可以看成为一个步骤。
如果线程A 操作dosome1 而线程而B 操作dosome2 如果不发生指令重排
可能顺序可能是 1,2,3 b=4 ,这也是我们期望的，
还会出现以下顺序
1,3,2 3,1,2 这两种可能性，如果是这两个，代表不符合条件，没有声明b变量。
但是如果发生重排后，因为1,2没有依赖关系，很有可能发生指令重排，那名执行的结果就可能出现以下顺序
2,3,1 如果出现这个顺序，就会声明变量b,结果为2；这个结果就会很恐怖了，就好比我们做了一个工程，每次执行的结果无法确定。这必然是不行的。为了解决这个问题，我们便可以用volatile来修饰变量。当然sychornized也可以解决。
重排是个比较麻烦的过程，这是一个简单理解，后续再做详细的探讨。
标签：Thread,验证,myData,代码,volatile,new,changeData,data,public 来源： https://www.cnblogs.com/atongmyuxiaowanzi/p/13457505.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。