volatile关键字

1 volatile关键字的作用

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

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

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

public classVolatileStopThread1 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{      VolatileStopThread1t=new VolatileStopThread1();      t.start();      Thread.sleep(1000);      t.stopMe();      Thread.sleep(1000);      }}

 

图1 没添加volatile的运行结果

public classVolatileStopThread2 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{      VolatileStopThread2t=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。