前言

“深入java虚拟机”中提到，int等不大于32位的基本类型的操作都是原子操作，但是某些jvm对long和double类型的操作并不是原子操作，这样就会造成错误数据的出现。其实这里的某些jvm是指32位jvm，64位jvm还是原子操作。

问题的根源

32jvm对于long和double变量，把它们作为2个原子性的32位值来对待，而不是一个原子性的64位值， 这样将一个long型的值保存到内存的时候，可能是2次32位的写操作， 2个竞争线程想写不同的值到内存的时候，可能导致内存中的值是不正确的结果。 如果多个线程操作同一个变量的时候，会分为如下几个步骤：

• (1) 写入高位32位值(线程1)
• (2) 写入低位32位值(线程1)
• (3) 写入高位32位值(线程2)
• (4) 写入低位32位值(线程2)

假如执行顺序为(1)(4)(3)(2)，这样内存中的值变成线程1的高32位值和线程2的低32位值的组合，是个错误的值。

long和double读写操作原子性测试

/**
 * long和double读写操作原子性测试
 *
 * @author liudong
 * @date 2021/11/25 17:08
 */
public class UnAtomicLong implements Runnable {
    private static long test = 0;

    private final long val;

    public UnAtomicLong(long val) {
        this.val = val;
    }

    @Override
    public void run() {
        while (!Thread.interrupted()) {
            //两个线程同时断写test变量，如果test变量的读写操作是原子性的，那么test只能是-1或者0
            test = val;
        }
    }

    private static String append(String s, int targetLength) {
        int n = targetLength - s.length();
        for (int x = 0; x < n; x++) {
            s = "0" + s;
        }
        return s;
    }

    public static void main(String[] args) {
        Thread t1 = new Thread(new UnAtomicLong(-1));
        Thread t2 = new Thread(new UnAtomicLong(0));

        System.out.println(Long.toBinaryString(-1));
        System.out.println(append(Long.toBinaryString(0), 64));

        t1.start();
        t2.start();

        long val;
        while ((val = test) == -1 || val == 0) {
            //如果test的操作是原子性的,那么就应该是死循环，否则就会跳出该循环
            System.out.println("原子操作！");
        }

        System.out.println(append(Long.toBinaryString(val), 64));
        System.out.println(val);

        t1.interrupt();
        t2.interrupt();
        System.out.println("非原子操作！");
    }
}

运行发现程序在while循环时进入了死循环，这是因为使用的JVM是64bits。在64位JVM中double和long的赋值操作是原子操作。换成32位JVM时程序就跳出了循环，说明赋值的过程被拆分了，也就没法保证原子性了。

如何解决

从Oracle Java Spec里面可以看到：

某些 JavaTM 实现可能发现将对 64 位 long 或 double 值的写操作分成两次相邻的 32 位值写操作更方便。为了效率起见，这种行为是实现可以自行决定的。JavaTM 虚拟 机可以自由地决定是原子性的对待 long 和 double 值的写操作还是一分为二的对 待。 鉴于本内存模型的目的，我们将对非 volatile long 或 double 值的单次写操作视作两 次分开的写操作：每次 32 位。这可能会导致一种情况，某个线程会看到某次写操 作中 64 位的前 32 位，以及另外一次写操作的后 32 位。读写 volatile 的 long 和 double 总是原子的。读写引用也总是原子的，而不管引用的实现采用的是 32 位还 是 64 位。 我们鼓励 VM 的实现者尽可能避免将 64 位值的写操作分开。鼓励编码人员将共享 的 64 位值声明为 volaitle 的或将其程序正确同步以避免可能的并发问题。

注意： 众所周知，volatile只能保证可见性不能保证原子性，但用volatile修饰long和double可以保证其操作原子性！