volatile的特性代码验证

一 . 可见性(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数据类,看一下执行结果

volatile的特性代码验证插图

 

 

 从结果可以看出,main线程一直就没有获取到数据更新信息,内存中的数据存储用图直观的看一下

volatile的特性代码验证插图(1)

 

 

 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 }

 

看一下执行结果

volatile的特性代码验证插图(2)

 

 发现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的特性代码验证插图(3)

 

 可以看到最终数据并不是我们想要的结果,多线程同时操作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 }

执行结果如下

volatile的特性代码验证插图(4)

 

 如此数据原子性问题便解决了。

三 . 指令重排

 在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也可以解决。

重排是个比较麻烦的过程,这是一个简单理解,后续再做详细的探讨。

 

本站资源均源自网络,若涉及您的版权、知识产权或其他利益,请附上版权证明邮件告知。收到您的邮件后,我们将在72小时内删除。
若下载资源地址错误或链接跳转错误请联系站长。站长q:770044133。

» volatile的特性代码验证

发表评论

免登录下载网,提供全网最优质的资源集合!