多线程不安全的缘由和基本的解决方案

时间 2019-12-06

标签多线程安全缘由基本解决方案栏目 Java 繁體版

原文原文链接

内容大纲

共享变量在内存中的可见性
什么是原子性
synchronized实现可见性和原子性的方式
volatile实现可见性的方式

Java内存模型（JMM）

Java内存模型（JMM）描述了Java程序中变量（线程公用变量）的访问规则(能够看作是一种规范),以及在JVM中将变量存储到内存和内存中读取出变量这样的底层细节。java

全部的变量都存储在主内存中
每一个线程都有本身独立的工做内存，里面保存该线程使用到的变量副本(主内存中该变量的一份拷贝)

而且规定:git

线程对共享变量的全部操做都必须在本身的工做内存中进行，不能直接从主内存中读写
不一样线程之间没法直接访问其余线程工做内存中的变量，线程间变量的传递主要经过主内存来完成

举个例子(修改线程A中的变量):安全

把工做内存A中更新过的共享变量刷新到主内存中
将主内存中的最新共享变量的值更新到工做内存B中

若是知足上面两点，也就是说线程A中更新的共享变量线程B中可以及时获得更新，就称为变量是可见的，反正则是不可见。多线程

共享变量、可见性和原子性

共享变量：若是一个变量在多个线程的工做内存中都存在副本，那么这个变量就是这几个线程的共享变量。
可见性：一个线程对共享变量值的修改，可以及时地被其余线程看到。
原子性: 一段指令像原子同样不可分割，在执行结束以前，其余线程不可打断。

指令重排序和`as-if-serial`

代码书写顺序与代码实际执行的顺序不一样，指令重排序是编译器或处理器为了提升程序性能而作出的优化。并发

主要有三种方式：ide

编译器优化的重排序（编译器优化,主要是单线程下，在保证执行结果正确的前提下，重排序代码顺序让代码更符合机器执行）
指令级并行重排序（处理器优化,主要为多核计算机同时执行作了优化）
内存系统的重排序（处理器优化,主要是运行内存，如主内存、工做内存进行重排序）

举个例子：性能

int a = 2;
int b = 3;
int c = a + b;

在实际运行中多是:优化

int b = 3;
int a = 2;
int c = a + b;

上述例子中演示了指令重排序，那么可能会有人问，第三行代码若是重排序到前两行代码以前，岂不是会报错吗？this

有一个as-if-serial,其内容以下：线程

不管如何重排序，程序执行的结果应该与代码顺序执行结果一致。（Java编译器、运行时和处理器都要保证Java在单线程下遵循as-if-serial语义）

所以在单线程的状况下你没必要担忧指令重排序带来什么不良后果。

可是在多线程交错执行时，重排序就可能形成内存可见性问题，详情请继续阅读下文。

多线程中的指令重排序

package cn.com.dotleo;

/**
 * Created by liufei on 2018/6/16.
 */
public class SynchronizedDemo {

    // 共享变量
    private boolean ready = false;
    private int result = 0;
    private int number = 1;

    // 写操做
    public void write() {
        ready = true;  // 1.1
        number = 2;  // 1.2
    }

    // 读操做
    public void read() {
        if (ready) {  // 2.1
            result = number * 3;  //2.2
        }
        System.out.println("result的值为:" + result);
    }

    private class ReadWriteThread extends Thread {
        private boolean flag;
        public ReadWriteThread(boolean flag) {
            this.flag = flag;
        }

        // 根据传入执行不一样的读写操做
        @Override
        public void run() {
            if (flag) {
                write();
            } else {
                read();
            }
        }
    }

    public static void main(String[] args) {
        SynchronizedDemo demo = new SynchronizedDemo();
        // 启动写线程
        demo.new ReadWriteThread(true).start();
        // 启动读线程
        demo.new ReadWriteThread(false).start();
    }

}

代码参见SynchronizedDemo

对于这个程序，若是执行main方法将可能有一下几种状况：

1.1 -> 2.1 -> 2.2 -> 1.2 result:3
1.2 -> 2.1 -> 2.2 -> 1.1 result:0

其实，2.1和2.2也是能够重排序的：

int temp = number * 3;
if (ready) {
    result = temp;
}

所以就有了：

2.2 -> 2.1 ->1.2 -> 1.1
...

致使共享变量线程不安全的缘由

到这里，能够总结一下为何会出现共享变量线程不安全的主要缘由了：

线程的交叉执行(原子性)
重排序结合线程的交叉执行(可见性)
共享变量更新后的值没有在工做内存中与主内存之间及时更新(可见性)

可见性的实现方式

从Java语言层面讲，主要支持一下两种方式：

Synchronized
Volatile

不包括JDK 1.5提供的Java并发包

Synchronized

JMM关于Synchronized的两条规定：

线程解锁前，必须把共享变量的最新值刷新到主内存中
线程加锁时，将清空工做内存中共享变量的值，使得使用共享变量时须要从主内存中从新获取最新的值。(加锁和解锁须要是同一把锁)

咱们先来修改一下原来的代码，保证其共享变量在多线程下的可见性。

// 写操做
    public synchronized void write() {
        ready = true;  // 1.1
        number = 2;  // 1.2
    }

    // 读操做
    public synchronized void read() {
        if (ready) {  // 2.1
            result = number * 3;  //2.2
        }
        System.out.println("result的值为:" + result);
    }

代码参见SafeSynchronizedDemo

为何这个操做能保证其可见性呢？咱们经过分析致使共享变量线程不可见的3个缘由逐一分析：

Synchronized关键词加锁后，保证了线程不会交叉执行
若是线程不交叉执行，那么不管如何重排序，都至关于单线程中的重排序，遵循as-if-serial语义
上面提到的Synchronized的两条规定能保证它及时获取而且在操做结束后及时更新主内存中的共享变量的值。

volatile

关于volatile，它有如下特性：

可以保证变量的可见性
不能保证变量的原子性

它的这些特性是经过内存屏障和禁止指令重排序优化来实现的。

对volatile变量执行写操做时，会在写操做后加入一条store屏障指令,让主内存中的变量及时更新
对volatile变量执行读操做时，会在读操做前加入一条load屏障指令，更新主内存中的变量

举一个volatile的例子说明它不具有原子性。

package cn.com.dotleo;

/**
 * Created by liufei on 2018/6/16.
 */
public class VolatileDemo {

    private volatile int num = 0;

    public int getNum() {
        return this.num;
    }

    public void increase() {
        this.num++;
    }

    public static void main(String[] args) {
        final VolatileDemo volatileDemo = new VolatileDemo();
        for (int i = 0; i < 500; i++) {
            new Thread(new Runnable() {
                public void run() {
                    volatileDemo.increase();
                }
            }).start();
        }

        // 为了让全部线程执行完毕
        // 若是还有子线程执行
        // 主线程让出cpu资源
        while (Thread.activeCount() > 1) {
            Thread.yield();
        }
        System.out.println("num" + volatileDemo.getNum());
    }
}

代码参见VolatileDemo

该程序的运行结果不老是500。由于increase()方法中的num++并不是原子操做，它包括了:

从主内存中获取num的值
num的值 + 1
将num + 1的值赋值给num

试分析一种状况：

线程A获取到num的值 = 0，因为它不是原子性，cpu资源被线程B抢走
线程B获取num的值 = 0
线程B对num + 1 = 1
线程B把num值更新到主内存中后结束
线程A从新得到cpu资源，对它内存中num的副本 + 1 = 1
线程A将num = 1更新到主内存中

至此，两次循环却少加了，致使并不是咱们想要的num最终 = 500

volatile适用场景

要在多线程中安全的使用volatile,必须同时知足：

对变量的写入操做不依赖当前值
该变量没有包含在具备其余变量的不变式中