Android 多线程之线程安全问题

什么是线程安全问题

线程安全问题不是说线程不安全,而是多个线程之间交错操作有可能导致数据异常。就比如两个线程同时对一个数据进行操作,不能保证最后得到是数据是正确的,这就出现了线程安全问题。

什么是Java内存模型

在这之前,先了解下Java内存模型是什么,这能帮助我们更好的理解线程的安全性问题。


Android 多线程之线程安全问题_第1张图片
Java内存模型

其实线程每次对数据操作,这些数据都是当前线程工作内存中的共享变量副本,并不是直接在主内存操作。每条线程都有自己的工作内存。

如果线程对变量的操作没有刷回主内存的话,仅仅改变了自己的工作内存的变量副本,那么对其他线程来说是不可见的,不知道这个变量发生变化。而如果一个变量没有读取内存中新值,而是使用旧的值去做后续操作的话,会得到一个错误的结果,这里体现出线程安全问题 -- 可见性

什么是Java线程调度

在任意时刻,CPU 只能执行一条机器指令,每个线程只有获取到 CPU 的使用权后,才可以执行指令。也就是在任意时刻,只有一个线程占用 CPU,处于运行的状态。

多线程并发运行实际上是指多个线程轮流获取 CPU 使用权,分别执行各自的任务。线程的调度由 JVM 负责,线程的调度是按照特定的机制为多个线程分配 CPU 的使用权。线程调度模型分为两类:分时调度模型和抢占式调度模型。

1、分时调度模型:让所有线程轮流获取 CPU 使用权,并且平均分配每个线程占用 CPU 的时间片。
2、抢占式调度模型:JVM 采用的是抢占式调度模型,也就是先让优先级高的线程占用 CPU,如果线程的优先级都一样,那就随机选择一个线程,并让该线程占用 CPU。也就是如果我们同时启动多个线程,并不能保证它们能轮流获取到均等的时间片。如果我们的程序想干预线程的调度过程,最简单的办法就是给每个线程设定一个优先级。

什么是数据依赖性

如果两个操作访问同一个变量,且这两个操作中有一个为写操作,此时这两个操作之间就存在数据依赖。数据依赖分下列三种类型:
1、写后读(a = 1;b = a;),写一个变量之后,再读这个位置。
2、写后写 (a = 1;a = 2;),写一个变量之后,再写这个变量。
3、读后写(a = b;b = 1;),读一个变量之后,再写这个变量。

上面三种情况,只要重排序两个操作的执行顺序,程序的执行结果将会被改变。所以,编译器和处理器在重排序时,会遵守数据依赖性,编译器和处理器不会改变存在数据依赖关系的两个操作的执行顺序。也就是说:在单线程环境下,指令执行的最终效果应当与其在顺序执行下的效果一致,否则这种优化便会失去意义。

如何保证线程安全

1、原子性
2、可见性
3、有序性
要实现线程安全就要保证上面说到的原子性、可见性和有序性。

原子性

在讲原子性之前先来看看这个例子:

a++,对于共享变量a的操作,实际上会执行三个步骤,
1.读取变量a的值
2.a的值+1
3.将值赋予变量a

这三个操作中任何一个操作过程中,a的值被人篡改,那么都会出现我们不希望出现的结果。在多线程中,a的值可能被其他线程修改,导致线程不安全。为了保证线程安全,必须把这三个步骤当成不可分割的一个整体操作,在其他线程看来,该操作只有未开始和结束的两种状态,不知道中间发生什么。这就体现了原子性。

在单线程环境下我们可以认为整个步骤都是原子性操作,但是在多线程环境下则不同,Java只保证了基本数据类型的变量和赋值操作才是原子性的。

注:基本数据类型的变量和赋值操作类似 i = 0 的操作

可见性

刚才讲到Java内存模型时,有提及到可见性。可见性是指一个线程对共享变量的更新,对于其他读取该变量的线程是否可见。怎么让修改完的数据可见呢?举个例子

① 将工作内存1中的共享变量的改变更新到主内存中
② 将主内存中最新的共享变量的变化更新到工作内存2中

Java提供了volatile关键字来保证可见性。通过synchronized和Lock也能够保证可见性,synchronized和Lock能保证同一时刻只有一个线程获取锁然后执行同步代码,并且在释放锁之前会将对变量的修改刷新到主存当中。因此可以保证可见性。

有序性

在Java内存模型中,允许编译器和处理器对指令进行重排序,但是重排序过程不会影响到单线程程序的执行,却会影响到多线程并发执行的正确性。举个例子

class ReorderExample {
    int a = 0;
    boolean flag = false;
 
    public void writer() {
        a = 1;          // 1
        flag = true;    // 2
    }
 
    public void reader() {
        if (flag) {          // 3
            int i = a * a; // 4
        }
    }
}

思考一下,flag变量是个标记,用来标识变量a是否已被写入。这里假设有两个线程A和B,A首先执行writer()方法,随后B线程接着执行reader()方法。线程B在执行操作4时,能否看到线程A在操作1对共享变量a的写入?

答案是:不一定能看到。

由于操作1和操作2没有数据依赖关系,编译器和处理器可以对这两个操作重排序;同样,操作3和操作4没有数据依赖关系,编译器和处理器也可以对这两个操作重排序。让我们先来看看,当操作1和操作2重排序时,可能会产生什么效果?

执行顺序是:2 -> 3 -> 4 -> 1 (这是完全存在并且合理的一种顺序,如果你不能理解,请先了解CPU是如何对多个线程进行时间分配的)

操作3和操作4重排序后,因为操作3和操作4存在控制依赖关系。当代码中存在控制依赖性时,会影响指令序列执行的并行度。为此,编译器和处理器会采用猜测(Speculation)执行来克服控制相关性对并行度的影响。以处理器的猜测执行为例,执行线程B的处理器可以提前读取并计算a*a,然后把计算结果临时保存到一个名为重排序缓冲(reorder buffer ROB)的硬件缓存中。当接下来操作3的条件判断为真时,就把该计算结果写入变量i中。我们可以看出,猜测执行实质上对操作3和4做了重排序。重排序在这里破坏了多线程程序的语义。

在Java里面,可以通过volatile关键字来保证一定的“有序性”。另外可以通过synchronized和Lock来保证有序性,很显然,synchronized和Lock保证每个时刻是有一个线程执行同步代码,相当于是让线程顺序执行同步代码,自然就保证了有序性。另外,Java内存模型具备一些先天的“有序性”,即不需要通过任何手段就能够得到保证的有序性,这个通常也称为 happens-before 原则。

happens-before原则(先行发生原则)

程序次序规则:一个线程内,按照代码顺序,书写在前面的操作先行发生于书写在后面的操作。

锁定规则:一个unLock操作先行发生于后面对同一个锁额lock操作。

volatile变量规则:对一个变量的写操作先行发生于后面对这个变量的读操作。

传递规则:如果操作A先行发生于操作B,而操作B又先行发生于操作C,则可以得出操作A先行发生于操作C。

线程启动规则:Thread对象的start()方法先行发生于此线程的每个一个动作。

线程中断规则:对线程interrupt()方法的调用先行发生于被中断线程的代码检测到中断事件的发生。

线程终结规则:线程中所有的操作都先行发生于线程的终止检测,我们可以通过Thread.join()方法结束、Thread.isAlive()的返回值手段检测到线程已经终止执行。

对象终结规则:一个对象的初始化完成先行发生于他的finalize()方法的开始。

总结

要实现线程安全就要保证上面说到的原子性、可见性和有序性。

注:提及到的volatile、synchronized和Lock后续写一篇关于锁的文章Android多线程之锁

你可能感兴趣的:(Android 多线程之线程安全问题)