java中的原子操作

Java中的原子操作包括：

1）除long和double之外的基本类型的赋值操作

2）所有引用reference的赋值操作

3）java.concurrent.Atomic.* 包中所有类的一切操作。

 

但是java对long和double的赋值操作是非原子操作！！long和double占用的字节数都是8，也就是64bits。在32位操作系统上对64位的数据的读写要分两步完成，每一步取32位数据。这样对double和long的赋值操作就会有问题：如果有两个线程同时写一个变量内存，一个进程写低32位，而另一个写高32位，这样将导致获取的64位数据是失效的数据。因此需要使用volatile关键字来防止此类现象。volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为volatile的long和double变量的get和set操作是原子的。（from http://www.iteye.com/topic/213794）

 

举个例子来说：（example is from http://stackoverflow.com/questions/17481153/long-and-double-assignments-are-not-atomic-how-does-it-matter）

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 = val; //两个线程都试图将自己的私有变量val赋值给类私有静态变量test

        }

    }

 

    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(pad(Long.toBinaryString(0), 64));

 

        t1.start();

        t2.start();

 

        long val;

        while ((val = test) == -1 || val == 0) { 

       //如果静态成员test的值是-1或0，说明两个线程操作没有交叉

        }

 

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

        System.out.println(val);

 

        t1.interrupt();

        t2.interrupt();

    }

 

    // prepend 0s to the string to make it the target length

    private static String pad(String s, int targetLength) {

        int n = targetLength - s.length();

        for (int x = 0; x < n; x++) {

            s = "0" + s;

        }

        return s;

    }

}

 

运行发现程序在while循环时进入了死循环，这是因为使用的JVM是64bits。在64位JVM中double和long的赋值操作是原子操作。

在eclipse中修改jre为一个32bit的JVM地址，则会有如下运行结果：

1111111111111111111111111111111111111111111111111111111111111111

0000000000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000011111111111111111111111111111111 

//很明显test的值被破坏了

4294967295

Java中的原子操作包括：

1）除long和double之外的基本类型的赋值操作

2）所有引用reference的赋值操作

3）java.concurrent.Atomic.* 包中所有类的一切操作。

 

但是java对long和double的赋值操作是非原子操作！！long和double占用的字节数都是8，也就是64bits。在32位操作系统上对64位的数据的读写要分两步完成，每一步取32位数据。这样对double和long的赋值操作就会有问题：如果有两个线程同时写一个变量内存，一个进程写低32位，而另一个写高32位，这样将导致获取的64位数据是失效的数据。因此需要使用volatile关键字来防止此类现象。volatile本身不保证获取和设置操作的原子性，仅仅保持修改的可见性。但是java的内存模型保证声明为volatile的long和double变量的get和set操作是原子的。（from http://www.iteye.com/topic/213794）

 

举个例子来说：（example is from http://stackoverflow.com/questions/17481153/long-and-double-assignments-are-not-atomic-how-does-it-matter）

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 = val; //两个线程都试图将自己的私有变量val赋值给类私有静态变量test

        }

    }

 

    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(pad(Long.toBinaryString(0), 64));

 

        t1.start();

        t2.start();

 

        long val;

        while ((val = test) == -1 || val == 0) { 

       //如果静态成员test的值是-1或0，说明两个线程操作没有交叉

        }

 

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

        System.out.println(val);

 

        t1.interrupt();

        t2.interrupt();

    }

 

    // prepend 0s to the string to make it the target length

    private static String pad(String s, int targetLength) {

        int n = targetLength - s.length();

        for (int x = 0; x < n; x++) {

            s = "0" + s;

        }

        return s;

    }

}

 

运行发现程序在while循环时进入了死循环，这是因为使用的JVM是64bits。在64位JVM中double和long的赋值操作是原子操作。

在eclipse中修改jre为一个32bit的JVM地址，则会有如下运行结果：

1111111111111111111111111111111111111111111111111111111111111111

0000000000000000000000000000000000000000000000000000000000000000

0000000000000000000000000000000011111111111111111111111111111111 

//很明显test的值被破坏了

4294967295