JAVA之long和double读写操作原子性

太过爱你忘了你带给我的痛 2022-05-25 08:25 213阅读 0赞

***Java虚拟机规范定义的许多规则中的一条：所有对基本类型的操作除了某些对long类型和double类型的操作之外，都是原子级的；***

> 当线程把主存中的 long/double类型的值读到线程内存中时，可能是两次32位值的写操作，显而易见，如果几个线程同时操作，那么就可能会出现高低2个32位值出错的情况发生。即long,double高低位问题，非线程安全

举例说明：

即如有一个long类型的field字段，某个线程正在执行 field = 123L ，而同时有另一个线程正在执行 field = 456L，这样的指定操作之后field的值会是什么，是无法保证的。也许是123L,也可能是456L，或许是0L,甚至还可能是31415926L

### JVM内存模型中定义了8中原子操作 ###

1.  lock:将一个变量标识为被一个线程独占状态
2.  unclock:将一个变量从独占状态释放出来，释放后的变量才可以被其他线程锁定
3.  read:将一个变量的值从主内存传输到工作内存中，以便随后的load操作
4.  load:把read操作从主内存中得到的变量值放入工作内存的变量的副本中
5.  use:把工作内存中的一个变量的值传给执行引擎，每当虚拟机遇到一个使用到变量的指令时都会使用该指令
6.  assign:把一个从执行引擎接收到的值赋给工作内存中的变量，每当虚拟机遇到一个给变量赋值的指令时，都要使用该操作
7.  store:把工作内存中的一个变量的值传递给主内存，以便随后的write操作
8.  write:把store操作从工作内存中得到的变量的值写到主内存中的变量

对于32位操作系统来说单次次操作能处理的最长长度为32bit，而long类型8字节64bit，所以对long的读写都要两条指令才能完成(即每次读写64bit中的32bit)；如果JVM要保证long和double读写的原子性，势必要做额外的处理

public class LongAtomTest implements Runnable {
    
        private static long field = 0;
    
        private volatile long value;
    
        public long getValue() {
            return value;
        }
    
        public void setValue(long value) {
            this.value = value;
        }
    
        public LongAtomTest(long value) {
            this.setValue(value);
        }
    
        @Override
        public void run() {
            int i = 0;
            while (i < 100000) {
                LongAtomTest.field = this.getValue();
                i++;
                long temp = LongAtomTest.field;
                if (temp != 1L && temp != -1L) {
                    System.out.println("出现错误结果" + temp);
                    System.exit(0);
                }
            }
            System.out.println("运行正确");
        }
    
        public static void main(String[] args) throws InterruptedException {
            // 获取并打印当前JVM是32位还是64位的
            String arch = System.getProperty("sun.arch.data.model");
            System.out.println(arch+"-bit");
            LongAtomTest t1 = new LongAtomTest(1);
            LongAtomTest t2 = new LongAtomTest(-1);
            Thread T1 = new Thread(t1);
            Thread T2 = new Thread(t2);
            T1.start();
            T2.start();
            T1.join();
            T2.join();
        }
    
    }

以上代码在32位JVM上和64位JVM上运行结果将不一致

从程序得到的结果来看，32位的HotSpot没有把long和double的读写实现为原子操作。 在读写的时候，分成两次操作，每次读写32位。因为采用了这种策略，所以64位的long和double的读与写都不是原子操作

### 结论 ###

*  对于64位的long和double，如果没有被volatile修饰，那么对其操作可以不是原子的。在操作的时候，可以分成两步，每次对32位操作；
 *  如果使用volatile修饰long和double，那么其读写都是原子操作；
 *  在实现JVM时，可以自由选择是否把读写long和double作为原子操作；
 *  java中对于long和double类型的写操作不是原子操作，而是分成了两个32位的写操作。读操作是否也分成了两个32位的读呢？在JSR-133之前的规范中，读也是分成了两个32位的读，但是从JSR-133规范开始，即JDK5开始，读操作也都具有原子性；
 *  java中对于其他类型的读写操作都是原子操作(除long和double类型以外)；
 *  对于引用类型的读写操作都是原子操作，无论引用类型的实际类型是32位的值还是64位的值；
 *  对于long类型的不恰当操作可能读取到从未出现过的值。而对于int的不恰当操作则可能读取到旧的值；