【Java并发编程学习】四、Volatile关键字

/**
 * volatile变量自增运算测试
 * 当一个变量定义为volatile以后，它将具有两种特性
 * 第一 是保证此变量对全部线程的可见性
 *      volatile变量在各个线程的工做内存中不存在一致性问题
 *      （在各个线程的工做内存中，volatile变量也能够存在不一致的状况，但因为每次使用以前都要先刷新，执行引擎看不到不一致的状况，
 *      所以能够认为不存在一致性问题），可是Java里面的运算并不是原子操做，致使volatile变量的运算在并发下同样是不安全的。
 *      因为volatile变量只能保证可见性，在不符合如下两条规则的运算场景中，仍然要经过加锁（使用synchronized或java.util.concurrent类）
 *      来保证原子性。
 *         a、运算结果并不依赖变量的当前值，或者可以确保只有单一的线程修改变量的值。
 *         b、变量不须要与其它的状态变量共同参与不变约束。    
 * 第二 禁止指令重排序优化
 */
public class VolatileTest {
    public static volatile int race = 0;

    public static void increase() {
        race++;
    }

    private static final int THREADS_COUNT = 20;

    public static void main(String[] args) {
        Thread[] threads = new Thread[THREADS_COUNT];
        for (int i = 0; i < THREADS_COUNT; i++) {
            threads[i] = new Thread(new Runnable() {
                @Override
                public void run() {
                    for (int i = 0; i < 10000; i++) {
                        increase();
                    }
                }
            });
            threads[i].start();
        }
        // 等待全部累加线程都结束
        while (Thread.activeCount() == 1) {
            Thread.yield();
        }

        System.out.println("[VolatileTest] race= " + race);
    }
}

# javap -c  VolatileTest.class

反编译部分截图

注：即便编译出来只有一条字节码指令，也并不意味执行这条指令就是一个原子操做。一条字节码指令在解释执行时，解释器将要运行许多行代码才能实现它的语义，若是是编译执行，一条字节码指令也可能转化成若干条本地机器码指令。

public class Singleton {
    private volatile static Singleton instance;

    public static Singleton getSingleton() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    public static void main(String[] args) {
        Singleton.getSingleton();
    }
}