volatile的特性代码验证

一 . 可见性（visibility）

volatile关键字修饰的变量，如果值发生了改变，其他线程会立刻获取到，从而避免了出现脏读的情况。

  public class TestVolatile {
       
      public static void main(String[] args) {
          MyData myData = new MyData();
          new Thread(new Runnable() {
              @Override
              public void run() {
                  System.out.println("进入操作数据线程");
                  try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 //调用方法 赋值 
                 myData.changeData();
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"操作数据线程").start();
 
         // 主线程查看数据是否改了
         while (myData.data == 0){
 
         }
        System.out.println("main线程结束");
     }
 }
  
 class MyData{
     int data = 0;
     public void changeData(){
         this.data = 2020;
     }
  
 }

 

如上面代码，有两个线程在操作MyDdata数据类，看一下执行结果

 

 

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

 

 

 main线程的内存线程并没获取到数据更新。

下面变量加上volatile的效果

 public class TestVolatile {
      
      public static void main(String[] args) {
          MyData myData = new MyData();
          new Thread(new Runnable() {
              @Override
              public void run() {
                  System.out.println("进入操作数据线程");
                  try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     e.printStackTrace();
                 }
                 //调用方法 赋值 
                 myData.changeData();
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"操作数据线程").start();
 
         // 主线程查看数据是否改了
         while (myData.data == 0){

         }
         System.out.println("main线程结束");
     }
 }
 
 class MyData{
     volatile int data = 0;
     public void changeData(){
         this.data = 2020;
     }
  
 }

 

看一下执行结果

 

 发现main方法已经获取到了数据更新。从而验证了volatile的可见性。

 

二 . 无法保证原子性

直接上代码

  public class TestVolatile1 {
      
     public static void main(String[] args) {
         MyData1 myData = new MyData1();
         
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程1").start();
 
         
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程2").start();
         
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程3").start();
         
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程4").start();
         
         while (Thread.activeCount() > 1) { 
             Thread.yield();
           }
         
         System.out.println("最终数值 ："+myData.data);
     }
 }
 
 class MyData1{
     volatile int data = 0;
     public void changeData(){
         data++;
     }
  
 }

 

咱们可以预测一下，如果正常的话，咱们应该得到的最终数据应该是40000 ，但结果如下

 

 可以看到最终数据并不是我们想要的结果，多线程同时操作volatile修饰变量，无法保证数据的原子性。

那如何解决这个问题呢，用sychornized，可以处理，但是这是重量级锁，不推荐使用，还可以用 AtomicInteger 来处理这个情况实现代码如下

  import java.util.concurrent.atomic.AtomicInteger;
  
  public class TestVolatile1 {
       
      public static void main(String[] args) {
          MyData1 myData = new MyData1();
          
          new Thread(new Runnable() {
              @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程1").start();
 
         
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程2").start();
         
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程3").start();
         
         new Thread(new Runnable() {
             @Override
             public void run() {
                 //调用方法 赋值 
                 myData.changeData();
                 for(int i = 0;i < 9999;i++) {
                      myData.changeData();
                    }
                 System.out.println(Thread.currentThread().getName()+" :  "+myData.data);
             }
         },"线程4").start();
         
         while (Thread.activeCount() > 1) { 
             Thread.yield();
           }
         
         System.out.println("最终数值 ："+myData.data);
     }
 }
 
 class MyData1{
     AtomicInteger data = new AtomicInteger();
     public void changeData(){
         data.getAndIncrement();
     }
  
 }

 

执行结果如下

 

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

三 . 指令重排

 在JVM在编译Java代码的时候，或者CPU在执行JVM字节码的时候，对指令顺序进行重新排序。在不改变程序执行结果的前提下，优化程序的运行效率（不改变单线程下的程序执行结果）

看一段简单的代码

 public class Data {
 
     int a = 1; //步骤1
     int b = 2; //步骤2
     int c = a+b; //步骤3
 
 }

 

单线程下，代码执行结果c的结果3，但是在执行的过程时候并不一定是1 ， 2，3这个执行顺序，在发生指令重排后，可能是2，1，3。单线程下对工程并没有什么影响。

但是如果是多线程，就会出现问题。查看如下方法

  public class Volatile {
  
      int a = 1;
      boolean flag = false;
      
     public void dosome1() {
          a = 2;// 步骤1
         flag = true; //步骤2
      }
     
     public void dosome2() {
         if(flag){    
             int b = a+a; // 步骤3 
         }
     }
 }

 

上面的代码步骤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也可以解决。

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