使用Volatile变量还是原子变量

• volatile变量

在Java语言中，volatile变量提供了一种轻量级的同步机制，volatile变量用来确保将变量的更新操作通知到其它线程，volatile变量不会被缓存到寄存器或者对其它处理器不可见的地方，所以在读取volatile变量时总会返回最新写入的值，volatile变量通常用来表示某个状态标识。

• 原子变量：

原子变量是“更强大的volatile”变量，从实现来看，每个原子变量类的value属性都是一个volatile变量，所以volatile变量的特性原子变量也有。同时，原子变量提供读、改、写的原子操作，更强大，更符合一般并发场景的需求。

既然原子变量更强大，是否还有必要使用volatile变量？如果有什么时候选择volatile变量，什么时候选择原子变量？当然这种选择只有在多线程并发的场景下才会出现，而多线程并发的目的一般是为了提高吞吐量和减少延迟响应，所以还是先看段测试代码和运行结果吧！

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164

import java.util.concurrent.CountDownLatch; import java.util.concurrent.atomic.AtomicInteger; public class TestVolatile {     private static int CALC_TIME = 1000;     private static final int THREAD_NUM = 100;     private AtomicInteger ai;     private int i;     private volatile int vi;                                                                                                                                                                                                                 public TestVolatile(){         ai = new AtomicInteger(0);         i = 0;         vi = 0;     }     public static void main(String[] args) throws InterruptedException {         System.out.println("Calculation Times:" + CALC_TIME + " ----------------------");         test();                                                                                                                                                                                                                         CALC_TIME = 10000;         System.out.println("Calculation Times:" + CALC_TIME + " ----------------------");         test();                                                                                                                                                                                                                         CALC_TIME = 100000;         System.out.println("Calculation Times:" + CALC_TIME + " ----------------------");         test();                                                                                                                                                                                                                         CALC_TIME = 1000000;         System.out.println("Calculation Times:" + CALC_TIME + " ----------------------");         test();     }     private static void test() throws InterruptedException {         testAi();                                                                                                                                                                                                                         testI();                                                                                                                                                                                                                         testVi();     }     private static void testAi() throws InterruptedException {         TestVolatile testVolatile = new TestVolatile();         CountDownLatch begSignal = new CountDownLatch(1);         CountDownLatch endSignal = new CountDownLatch(THREAD_NUM);         for (int i = 0; i < THREAD_NUM; i++) {                   new Thread( testVolatile.new WorkerAI(begSignal, endSignal) ).start();         }         long startTime = System.currentTimeMillis();                                                                                                                                                                                                                         begSignal.countDown();         endSignal.await();                                                                                                                                                                                                                         long endTime = System.currentTimeMillis();                                                                                                                                                                                                                         System.out.println("Total time consumed by atomic increment : " + (endTime-startTime));     }     private static void testI()             throws InterruptedException {         TestVolatile testVolatile = new TestVolatile();         CountDownLatch begSignal = new CountDownLatch(1);         CountDownLatch endSignal = new CountDownLatch(THREAD_NUM);                                                                                                                                                                                                                         for (int i = 0; i < THREAD_NUM; i++) {                   new Thread( testVolatile.new WorkerI(begSignal, endSignal) ).start();         }         long startTime = System.currentTimeMillis();                                                                                                                                                                                                                         begSignal.countDown();         endSignal.await();                                                                                                                                                                                                                         long endTime = System.currentTimeMillis();                                                                                                                                                                                                                         System.out.println("Total time consumed by synchronized increment : " + (endTime-startTime));     }                                                                                                                                                                                                                 private static void testVi()             throws InterruptedException {         TestVolatile testVolatile = new TestVolatile();         CountDownLatch begSignal = new CountDownLatch(1);         CountDownLatch endSignal = new CountDownLatch(THREAD_NUM);                                                                                                                                                                                                                         for (int i = 0; i < THREAD_NUM; i++) {                   new Thread( testVolatile.new WorkerVI(begSignal, endSignal) ).start();         }         long startTime = System.currentTimeMillis();                                                                                                                                                                                                                         begSignal.countDown();         endSignal.await();                                                                                                                                                                                                                         long endTime = System.currentTimeMillis();                                                                                                                                                                                                                         System.out.println("Total time consumed by volatile increment : " + (endTime-startTime));     }     public void incrAi() {         ai.getAndIncrement();     }     public synchronized void incrI() {         i++;     }     /**      * 这个函数不是线程安全，很可能得到错误的结果，这里只是为了测试读取volatile变量的效率      */     public void incrVi() {         vi++;     }     class WorkerAI implements Runnable {         private CountDownLatch beginSignal;         private CountDownLatch endSignal;         public WorkerAI(CountDownLatch begin, CountDownLatch end) {             this.beginSignal = begin;             this.endSignal = end;         }         @Override         public void run() {             try {                 beginSignal.await();             } catch (InterruptedException e) {                 e.printStackTrace();             }             for(int j=0; j<CALC_TIME; j++){                 incrAi();             }                                                                                                                                                                                                                                 endSignal.countDown();         }     }     class WorkerI implements Runnable {         private CountDownLatch beginSignal;         private CountDownLatch endSignal;         public WorkerI(CountDownLatch begin, CountDownLatch end) {             this.beginSignal = begin;             this.endSignal = end;         }         @Override         public void run() {             try {                 beginSignal.await();             } catch (InterruptedException e) {                 e.printStackTrace();             }             for(int j=0; j<CALC_TIME; j++){                 incrAi();             }                   endSignal.countDown();         }     }     class WorkerVI implements Runnable {         private CountDownLatch beginSignal;         private CountDownLatch endSignal;         public WorkerVI(CountDownLatch begin, CountDownLatch end) {             this.beginSignal = begin;             this.endSignal = end;         }         @Override         public void run() {             try {                 beginSignal.await();             } catch (InterruptedException e) {                 e.printStackTrace();             }             for(int j=0; j<CALC_TIME; j++){                 incrVi();             }             endSignal.countDown();         }     } }

程序运行结果：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

Calculation Times:1000 ---------------------- Total time consumed by atomic increment : 8 Total time consumed by synchronized increment : 6 Total time consumed by volatile increment : 5 Calculation Times:10000 ---------------------- Total time consumed by atomic increment : 23 Total time consumed by synchronized increment : 24 Total time consumed by volatile increment : 15 Calculation Times:100000 ---------------------- Total time consumed by atomic increment : 354 Total time consumed by synchronized increment : 360 Total time consumed by volatile increment : 148 Calculation Times:1000000 ---------------------- Total time consumed by atomic increment : 3579 Total time consumed by synchronized increment : 3608 Total time consumed by volatile increment : 1519

（怀疑自己的程序写得有问题，但暂时找不到问题，请大家帮忙拍砖！）

从测试结果看，原子变量的效率与synchronized同步操作效率差不多，感觉不到优势，volatile变量提升一倍的性能（当然++操作是有同步问题），所以如果volatile变量能满足需求优先使用volatile变量，原子变量次之。那什么时候适合使用volatile变量？专家推荐最佳实践是同时满足以下三个条件：

1. 对变量的写入操作不依赖变量的当前值，或者能确保只有单个线程更新变量的值

2. 改变量不会与其他状态变量一起组成不变性的条件

3. 在访问变量时不需要加锁

个人实践总结：

满足条件的情况下使用volatile布尔变量，其他数据类型使用原子变量。