volatile的原子性

volatile的原子性

五月 23, 2020

volatile的两个优点

volatile可以保证可见性，有序性，但是不能保证原子性，这也是今天写代码时候忽略的问题。

什么是原子性

原子性即一个操作或者多个操作 要么全部执行并且执行的过程不会被任何因素打断，要么就都不执行。

测试代码

初始问题版

1
2
3
4
5
6
7
8
9
10
11
public class Part implements Runnable {
    private volatile static int a = 0;
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println("a = " + a);
            a++;
        }

    }
}

主函数

1
2
3
4
5
6
7
8
9
10
public class Test {
    public static void main(String[] args) throws Exception {
        Part a = new Part();
        Part b = new Part();
        Thread t1 = new Thread(a);
        Thread t2 = new Thread(b);
        t1.start();
        t2.start();
    }
}

有两个线程，正常想要的结果应该是输出0~19，一共20个数。但是运行完的结果如下：

a = 0
a = 1
a = 2
a = 0
a = 3
a = 4
a = 6
a = 5
a = 7
a = 8
a = 9
a = 11
a = 10
a = 13
a = 12
a = 15
a = 14
a = 16
a = 18
a = 17

答案和我们预期不一样，这就是原子性的问题。

a++这个操作有三个步骤，读取值，自增，再写入。
假设发生下面这种情况：线程a读取了a=1，此时还没自增，线程b也读取了a=1。他们再执行自增操作，最后写回内存的就是2，而不是3。没有保证原子性。

解决方案： 可以通过synchronized或lock，进行加锁，来保证操作的原子性。也可以通过使用AtomicInteger。
我用AutomicInteger修改之后的：

1
2
3
4
5
6
7
8
9
10
public class Part implements Runnable {
    private volatile static AtomicInteger a = new AtomicInteger(0);
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
        //这个方法先自增，再返回自增之后的值，所以是1~20
            System.out.println("a = " + a.incrementAndGet() );
        }
    }
}

本篇只是粗略讲了一下volatile，没有说明工作内存和主存的关系，详细的看这个 -> 从计算机的角度理解volatile。