[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 + 原子变量 方式可以同时保证多线程环境下安全的变量读写。