多线程环境下的volatile_多线程共享变量volatile

1. 什么是volatile？

volatile是Java虚拟机提供的轻量级的同步机制，有以下特性：

• 禁止指令重排。
• 保证可见性。
• 不保证原子性。

2. JMM（Java内存模型）

为了解决多线程的安全性问题，提出了JMM即Java内存模型，JMM是一种规范，有以下规定：

• 线程解锁前，必须把共享变量的值刷新回主内存。
• 线程加锁前，必须把从主内存读取最新的值到自己的工作内存。
• 加锁和解锁必须是同一把锁。

2.1 volatile可见性的理解

线程操作共享变量都是先把共享变量的值读到自己的工作内存中再进行操作，操作完后写回到主内存。volatile就是一种通知机制，当主内存的共享变量发生了改变，就会通知其它线程重新从主内存读取共享变量的最新值，这就是所谓的可见性。

2.1 可见性的测试

class MyData{
     int num = 0;
    public void add(){
        num = 10;
    }
}
public class VolatileTest {
    public static void main(String[] args) {
        MyData myData = new MyData();
        new Thread(()->{
            System.out.println(Thread.currentThread().getName()+"\t进入");
            try {
                TimeUnit.SECONDS.sleep(3);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            myData.add();
            System.out.println(Thread.currentThread().getName()+"\t修改为：" + myData.num);
        },"线程A").start();

        while (myData.num == 0){

        }
        System.out.println(Thread.currentThread().getName() + "\t任务完成！");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

加volatile之前，虽然线程A修改了num的值，但是main线程还不知道，一直循环等待。

在共享变量上加volatile修饰。

class MyData{
    volatile int num = 0;
    public void add(){
        num = 10;
    }
}
1
2
3
4
5
6

加上volatile之后，num的值被修改后，会通知main线程从主内存获取num的最新值。

2.2 不保证原子性

代码测试

class MyData{
    volatile int num = 0;
    public void addPlusPlus(){
        num++;
    }
}
public class VolatileTest {
    public static void main(String[] args) {
        MyData myData = new MyData();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    myData.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "\t计算的结果为："+myData.num);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

每个线程计算1000次，总共20个线程，如果保证原子性的话，最后的结果应该是20000，可是结果并不能达到预期。

num++字节码被大概分为三步：getfield获取num原始值，iadd对num加一，putfield写回到主内存。但是在多线程环境下，其它线程没来得及获取最新值就进行操作写入，导致写覆盖数据丢失。

2.3 原子性的解决

对于i++，可以替换为原子操作AtomicInteger。

class MyData{
    AtomicInteger atomicInteger = new AtomicInteger();
    public  void addPlusPlus(){
        atomicInteger.getAndIncrement();
    }
}
1
2
3
4
5
6

        MyData myData = new MyData();
        for (int i = 0; i < 20; i++) {
            new Thread(()->{
                for (int j = 0; j < 1000; j++) {
                    myData.addPlusPlus();
                }
            }, String.valueOf(i)).start();
        }
        while (Thread.activeCount() > 2){
            Thread.yield();
        }
        System.out.println(Thread.currentThread().getName() + "\t计算的结果为："+myData.atomicInteger);
1
2
3
4
5
6
7
8
9
10
11
12

2.4 指令重排

多线程环境下，由于编译器优化进行指令重排，导致多个线程使用的变量一致性难以得到保证，最后的结果具有不确定性。

    int a = 0;
    boolean flag = false;
    public void m1(){
        a = 1;      //语句1
        flag = true; //语句2
    }
    public void m2(){
        if (flag)
        a = a + 2;
    }
1
2
3
4
5
6
7
8
9
10

指令重排后，可能变成语句2在语句1前面执行，导致m2方法的执行，a的结果是2，但按照正常顺序执行，a的结果应该是3。使用volatile可以禁止指令重排，保证程序的正确性和确定性。