Java中volatile关键字解析

1.volatile关键字

概念：JVM提供的一个轻量级的同步机制。

作用：

• 防止JVM对long/double等64位非原子性协议进行误操作（读取半个数据）。
• 可以使变量对所有的线程立即可见（某一个线程如果修改了工作内存中的变量副本，那么加上volatile之后，该变量就会立刻同步到其他线程的工作内存中）。
• 禁止指令的“重排序”优化。
  • 原子性：不可拆分（num = 10）。
  • 非原子性：可以拆分为原子性（int num = 10 -> int num 和 num = 10）。
  • 重排序：
    • 排序对象是原子性操作，目的是为了提高或优化执行效率。
    • 重排序不会影响单线程的执行结果。

volatile如何实现重排序问题：
通过“内存屏障”防止重排序问题：

• 在volatile写操作前，插入StoreStore屏障。
• 在volatile写操作后，插入StoreLoad屏障。
• 在volatile读操作前，插入LoadLoad屏障。
• 在volatile读操作后，插入LoadStore屏障。

2.volatile不能保证原子性、线程安全：

开启100个线程，每个线程分别对num进行30000次累加，如下：

public class Main {
    static volatile int num = 0;
    public static void main(String[] args) throws InterruptedException {
        // for循环开启100个线程
        for (int i = 0; i < 100; i++) {
            // lamda表达式，()表示无返回值
            new Thread(() -> {
                // 每个线程将num进行累加
                for (int j = 0; j < 30000; j++) {
                    // 非原子性操作
                    num++;
                }
            }).start();
        }
        // 将子线程暂停1000ms；否则Main方法线程先执行完，导致子线程提前结束
        Thread.sleep(2000);
        // 在线程安全的情况下num应该为3000000，但是volatile存在线程不安全，导致结果没有3000000万
        System.out.println(num);
    }
}

最后结果输出如下：

发现没有达到预期的3000000。why？
因为num++不是原子性：

num++ -> num = num + 1 -> num、num + 1。

拆分为原子性执行步骤如下：

1. 先num + 1。
2. 再将num + 1赋值给num。
   例如：假设num = 10，当两个线程同时执行了步骤1

• A线程：10 + 1 = 11。
• B线程：10 + 1 = 11。
• 这时A、B线程同时将11赋给num。

解决线程安全问题如下：

方法1：

synchronized加锁：

public class Main {
    static volatile int num = 0;
    public static void main(String[] args) throws InterruptedException {
        // for循环开启100个线程
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                synchronized (Main.class) {
                    // 每个线程将num进行累加
                    for (int j = 0; j < 30000; j++) {
                        num++;
                    }
                }
            }).start();
        }
        Thread.sleep(2000);
        System.out.println(num);
    }
}

缺点：会开销大量锁。

方法2：

使用AtomicInteger原子整型属性：

import java.util.concurrent.atomic.AtomicInteger;

public class Main {
    static AtomicInteger num = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        // for循环开启100个线程
        for (int i = 0; i < 100; i++) {
            new Thread(() -> {
                // 每个线程将num进行累加
                for (int j = 0; j < 30000; j++) {
                    num.incrementAndGet();
                }
            }).start();
        }
        Thread.sleep(2000);
        System.out.println(num);
    }
}

总结：

• AtomicInteger保证了原子性、线程安全，可以使用子包java.util.concurrent.atomic的类，该类是保证了原子性的核心。
• 因为提供了unsafe的compareAndSwap方法，该方法使用了CAS算法（无锁算法）。