[Java多线程] volatile 关键字正确使用方法

volatile 变量具有 synchronized 的可见性特性，但是不具备原子特性，即多线程环境中，使用 volatile 关键字的变量仅可以保证不同线程读取变量时，可以读到最新修改的变量值，但是修改变量值时，却不能保证线程安全(可能存在写值覆盖现象)。以下测试代码，展示了使用volatile关键字的几种方式。

 /**
  * <b>volatile 关键字正确用法</b><br>
  * @author        Gaylen
  * @version        V1.1.0
  * history
  * 1.1.0, 2014年11月20日        Gaylen            FE
  * @since        Java 6.0
  */
 public class TestVolatile {     /** volatile + atomic 保证读写安全 */
     public static volatile AtomicInteger count1 = new AtomicInteger(0);     /** volatile 实现读安全，但不能保证写安全 */
     public static volatile int count2 = 0;     /** volatile + synchronized 实现读写安全 */
     public static volatile int count3 = 0;     /** static 仅保证全局唯一，但不能保证读写安全 */
     public static int count4 = 0;     public static synchronized void count3Increment() {
         TestVolatile.count3++;
     }     /** 测试线程数 */
     public static final int numOfThread = 1000;     /** 线程辅助类，保证所有线程执行完毕 */
     private static CountDownLatch countDownLatch = new CountDownLatch(numOfThread);     public static void increment() {
         try {
             Thread.sleep(1);
         } catch (InterruptedException e) {
         }
         count1.getAndIncrement();
         count2++;
         count3Increment();
         count4++;
     }     /**
      * 输出结果
      * 等待所有线程执行完毕后，输出结果
      */
     public static void print() {
         try {
             countDownLatch.await();
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
         System.out.println("运行结果: count1=" + TestVolatile.count1.get());
         System.out.println("运行结果: count2=" + TestVolatile.count2);
         System.out.println("运行结果: count3=" + TestVolatile.count3);
         System.out.println("运行结果: count4=" + TestVolatile.count4);
         System.out.println("---------------------------------------");     }     /**
      * <b>程序入口</b><br>
      * 同时启动1000个线程，进行增加操作
      * @param args
      */
     public static void main(String[] args) {
         for (int i = 0; i < numOfThread; i++) {
             new Thread(new Runnable() {                 @Override
                 public void run() {
                     for (int index = 0; index < 1000; index++) {
                         TestVolatile.increment();
                     }
                     countDownLatch.countDown();
                 }
             }).start();
         }
         print();
     }
 }

测试程序输出结果如下：

运行结果: count1=1000000
运行结果: count2=998528
运行结果: count3=1000000
运行结果: count4=999892
—————————————

通过测试程序可知，使用 volatile + synchronized 方式 或者 volatile + 原子变量 方式可以同时保证多线程环境下安全的变量读写。