volatile实践，必须弄懂它！

 

这篇文章算是重构了，知识这种东西，理解的不深，用的就犹豫

 

为什么会线程不安全？

计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中会涉及到数据的读取和写入。程序运行过程中的临时数据是存放在主存（物理内存）当中的，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。

为了处理这个问题，在CPU里面就有了高速缓存(Cache)的概念。当程序在运行过程中，会将运算需要的数据从主内存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。这个高速缓存就是工作内存

规则：

Java内存模型规定所有的变量都是存在主存当中（类似于前面说的物理内存），每个线程都有自己的工作内存（类似于前面的高速缓存）。线程对变量的所有操作都必须在工作内存中进行，而不能直接对主存进行操作。并且每个线程不能访问其他线程的工作内存。

 

volatile如何解决这个问题？

对于多线程来说，注意三个特性：1.原子性，2.有序性，3.可见性，这三个特性保证了多线程的安全，这里不讲述

volatile保证了1.可见性；2.有序性； 注意不保证原子性；

可见性

含义：在多线程环境下，某个共享变量如果被其中一个线程给修改了，其他线程能够立即知道这个共享变量已经被修改了，当其他线程要读取这个变量的时候，最终会去主内存中读取，即读取的是最新的值

如int a = b+1，一个线程执行此操作，另一个线程执行读，那么只要a是+1后，读取的时候一定是最新的值

如配置中心修改某值，若用volatile修饰此共享变量则会立即生效

有序性

当我们把代码写好之后，虚拟机不一定会按照我们写的代码的顺序来执行

虚拟机在进行代码编译优化的时候，对于那些改变顺序之后不会对最终变量的值造成影响的代码，是有可能将他们进行重排序的

重排序可能会造成线程安全的问题

如果共享变量被volatile修饰，虚拟机会保证这个变量之前的代码一定会比它先执行，而之后的代码一定会比它慢执行。不论之前还是之后，它都无法保证重排序，只能保证当前修饰的变量前后是禁止重排序的

 

虽然volatile能够保证其他线程立即可见，可见不代表  现有的值一定要重新获取，不代表它是线程安全的，因为多个线程修改共享变量就会有问题

volatile线程不安全的栗子

栗子：

int a = a+1

执行过程为：

1. 从内存中读取a的值。
2. 进行a = a + 1这个运算
3. 把a的值写回到内存中

如果是两个线程同时读取到b为0，分别+1，写回主内存的值就是1，线程不安全。

栗子：起100个线程，循环100次

public static volatile int t = 0;
public static void main(String[] args) throws InterruptedException {
    for (int i=0;i<100;i++){
        for (int j=0;j<100;j++){
            new Thread(new Runnable() {
                @Override
                public void run() {
                    t = t + 1;
                }
            }).start();
        }
        //打印t的值
        System.out.println(t);
        Thread.sleep(1000);
        t = 0;
    }
}

98

98

99

98

99

99

99

下面用AtomicInteger来保证线程安全 

    public static AtomicInteger t = new AtomicInteger(0);
    public static void main(String[] args) throws InterruptedException {
        for (int i=0;i<100;i++){
            for (int j=0;j<100;j++){
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        int x = t.incrementAndGet();
                        System.out.println("t after "+x);
                    }
                }).start();
            }
            //打印t的值
            Thread.sleep(2000);//每隔2s置0重计数
            System.out.println(t);
            t = new AtomicInteger(0);
        }
    }

执行结果大家想想看应该是什么样的，然后自己运行一下

所以volatile在满足以下两个条件可以保证变量的线程安全问题

1.运算结果不依赖于变量的当前值，或者能够确保只有单一的线程修改变量的值

2.变量不需要与其他状态变量共同参与不变约束

所以可以在操作动作上    可以用JUC包，synchronized，Lock来控制原子性，保证线程安全 

 

参考：https://www.cnblogs.com/kubidemanong/p/9505944.html