volatile关键字

1 volatile关键字的作用

volatile关键字是JVM提供的一种轻量级的同步机制，主要要2种作用：

1.1 保证此变量对所有线程的可见性

即一个线程修改了公共数据，新值对于其他线程来说是可以立即得知的。

 

public class VolatileStopThread1 extends Thread {
   private boolean stop = false;
 
   public void stopMe() {
      stop = true;
   }
 
   public void run() {
      int i = 0;
      System.out.println(Thread.currentThread().getName()+  " " + System.currentTimeMillis());
      while (!stop) {
        i++;
      }
   System.out.println(Thread.currentThread().getName()+ " "+ System.currentTimeMillis());
      System.out.println("Stop thread");
   }
  
   public static void main(String args[]) throws InterruptedException{
      VolatileStopThread1 t = new VolatileStopThread1();
      t.start();
      Thread.sleep(1000);
      t.stopMe();
      Thread.sleep(1000);
      }
}

 

图1 没添加volatile的运行结果

 

 

public class VolatileStopThread2 extends Thread {
   private volatile boolean stop = false;
 
   public void stopMe() {
      stop = true;
   }
 
   public void run() {
      int i = 0;
      System.out.println(Thread.currentThread().getName()+  " " + System.currentTimeMillis());
      while (!stop) {
        i++;
      }
      System.out.println(Thread.currentThread().getName()+ " "+ System.currentTimeMillis());
      System.out.println("Stop thread");
   }
  
   public static void main(String args[]) throws InterruptedException{
      VolatileStopThread2 t = new VolatileStopThread2();
      t.start();
      Thread.sleep(1000);
      t.stopMe();
      Thread.sleep(1000);
      }
}

 

图2  添加volatile的运行结果

 

结果分析：

1）从图1中可以看出，线程Thread-0处于死循环，这是因为其每次从工作内存中获取数据，所以只能读到stop = false。

2）从图2中可以看出，线程Thread-0能够跳出循环。这是因为共享变量加了volatile关键之后，线程被强制从主内存中读取共享数据，从而保证一个线程更新的数据能够被另外一个线程读取到。

 

1.2 禁止指令重排优化

 

   int a = 0;
   volatile boolean flag = false;
 
   // 线程A访问方法writer（）
   public void writer() {
      a = 1;
      flag = true;
   }
 
   // 线程B访问方法writer（）
   public void reader() {
      if (flag) {
        try {
           throw new Exception();
        }catch(Exception e) {
           e.printStackTrace();
        }
      }else{
        System.out.println(a);
      }
   }

 

结果分析：

通过上面的伪代码可以看出，如果flag没有被volatile修饰，就可能会由于指令重排序的优化，导致writer方法中flag = tru被提前执行，从而导致线程B访问出错。

 

2 volatile关键字的非原子特性

Volatile虽然能够保证共享变量在线程之间的可见性，却不具备原子性。

 

public classVolatileAtomicTest1 {
   public static volatile int race = 0;
  
   public static void increase(){
      race ++;
   }
  
   private static final int THREADS_COUNT= 20;
  
   public static void main(String[] args) throws InterruptedException {
      Thread[]threads= newThread[THREADS_COUNT];
      for(int i = 0; i < 10; i++){
        threads[i] = new Thread(new Runnable() {
          
           @Override
           public void run() {
              for(int i = 0; i < 10000; i++){
                 increase();
              }
           }
        });
        threads[i].start();
      }
     
      Thread.sleep(2000);
      System.out.println(race);
   }
}

图 3 未添加synchronized的运行结果

 

 

 

 

 

public classVolatileAtomicTest2 {
   public static volatile int race = 0;
  
   public synchronized static void increase(){
      race ++;
   }
  
   private static final int THREADS_COUNT= 20;
  
   public static void main(String[] args) throws InterruptedException {
      Thread[]threads= newThread[THREADS_COUNT];
      for(int i = 0; i < 10; i++){
        threads[i] = new Thread(new Runnable() {
          
           @Override
           public void run() {
              for(int i = 0; i < 10000; i++){
                 increase();
              }
           }
        });
        threads[i].start();
      }
     
      Thread.sleep(2000);
      System.out.println(race);
     
   }
}

 

图片4 添加synchronized的运行结果

 

 

结果分析：

理论上结果应该是100000，但是图3的结果却是79671。这是因为代码中race++这一行不是原子操作，是非线程安全的，其可以分为3个步骤，从主内存中读取出race的值，计算race的值和将race的值写入主内存中。假如一个线程在计算race的值，而另外一个线程也在修改race的值，这样就会出现脏读。

 

3 关键字volatile和synchronized的区别

3.1 关键字volatile只能修饰变量，而synchronized可以修饰方法和代码块。

3.2 多线程访问volatile关键字不会发生阻塞，而synchronized会出现阻塞。

3.3 volatile关键字只能保证数据的可见性，不能保证原子性；而synchronized可以保证原子性和可见性。

 

4 发展趋势

随着JDK新版本的发布，synchronized关键字的性能不断提高，因此在处理并发操作时，优先选择synchronized关键字而非volatile。