吃透Java线程安全问题

清疚 2024-04-23 15:35 42阅读 0赞

**目录**

一、什么是线程安全

二、造成线程不安全的原因

? 对原子性在多线程并发执行中出现问题的分析

?优化过程中所造成的线程不安全

1、内存可见性引起的安全问题

2、指令重排序引起的安全问题

三、总结

对集合类安全性的一点补充：

线性安全的集合类

线性不安全的集合类

--------------------

## 一、什么是线程安全 ##

想给出一个线程安全的确切定义是复杂的，但我们可以这样认为：  
**如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的**

**?栗子**

package Thread;
    
    public class demo77 {
        private static int count;
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
            });
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
            });
            t1.start(); // 两个线程在创建好了后，线程所对应的PCB加入到系统链表，参与系统调度
            t2.start();
            // 让主线程main等t1、t2执行完了再接着往下走
            t1.join();
            t2.join();
            System.out.println(count);
        }
    }

![f35358cba8b1408ab904ad1246d58175.png][]

想这样，在多线程情况下，程序的运行结果不符合我们的预期，这被称为线程不安全

--------------------

## 二、造成线程不安全的原因 ##

**根本原因：操作系统的随机调度执行，抢占式执行**

> 还有：**我们可以看到我们的count是一个全局变量，我们的线程t1、线程t2对count变量同时都进行了修改——++操作**（为什么说是同时呢，因为我们的t1线程、t2线程在创建完了后就参与到系统调度，由系统随机分配线程的执行，可能是t2线程先执行10个指令然后t1再执行10个指令，相当于是同时）

**那么我们就改一下代码让t1、t2分批次对count修改不就行了吗？**

package Thread;
    
    public class demo77 {
        private static int count;
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
    
            });
            Thread t2 = new Thread(() -> {
                try {
                    t1.join();// 等t1线程执行完了，t2线程再执行
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                for (int i = 0; i < 5000; i++) {
                    count++;
                }
            });
            t1.start(); // 两个线程在创建好了后，线程所对应的PCB加入到系统链表，参与系统调度
            t2.start();
    
            t2.join(); // 等t2线程执行完了，主线程main再接着执行，执行顺序：t1->t2->打印count
            System.out.println(count);
        }
    }

![0e75d685db6f419586e815248f939b3d.png][]

**大家有没有想过为什么多个线程同时执行count++的时候就会出现BUG呢？**

**这是因为我们多个线程同时对同一变量修改的所造成的BUG往往和我们操作的原子性有关！！！这时候的操作往往不是一个整体，多个线程并发执行这些操作就可能出现一些问题**

**如果我们在变量修改过程中，操作是原子的——只是对应一个机器指令，那么即使是多个线程同时对同一个变量修改也不一定会造成BUG,但也可能造成BUG——要看具体的业务场景**

**总之我们要避免多个线程同时对同一个变量来操作**

![af5cc27030cf487a81d2cb674906c712.png][]

### ? 对原子性在多线程并发执行中出现问题的分析 ###

**??注意：**

![6749c1d243dd4139ae1d71bb13238fc6.png][]

> **当我们执行t1.start()、t2.start()后，t1线程和t2线程就在操作系统内核中创建出来了**，**t1、t2线程就参与到了系统调度当中**
> 
> 而调度是随机的——他可能先让t1执行几个指令，然后t2再执行几个指令、最后再把CPU的控制权交给t1。

于是因为系统的调度是随机的（**这是罪魁祸首，但我们无法改变）**，当我们**多个线程同时执行一些不是整体的操作的时候（++或--）**由于并发就会产生一些问题：

**?栗子一**

![15ac811137144c5abc01c49068c5a363.png][]

**?栗子二**

![2cb8f0784e024604a6c09d38882f0676.png][]

为什么会产生上面的BUG呢？

就是因为我们的++操作不是一个整体，是一个由多个指令所组成的操作

**解决方案：也是加锁：“synchronized”,意味着把这三条指令打包成了一组指令，然后把这一组指令看出成一条指令了，类似于数学里的“整体代换”思想。**

![82dc94c8208f479e86508569793a36be.png][]

首先我们要明白加锁操作都是针对某一个对象来进行的**（加锁本质就是给对象头里设置个标记）**，加锁有以下几种形式

形式一、

![6f7db6896d464b26a07d7eccc52b66dd.png][]

形式二、

package Thread;
    
    class Counter {
        public static int count;
    //    public synchronized void increase() {
    //        ++count; 这两种写法视为是等价的
    //    }
        public void increase() {
            synchronized (this) { // 这里this可以是任意对象，this可以有多个Counter counter1 = new Counter(), Counter counter2 = new Counter();
                ++count;
            }
        }
    }
    public class demo777 {
    
        public static void main(String[] args) throws InterruptedException {
            Counter counter1 = new Counter();
            Counter counter2 = new Counter();
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 5000; i++) {
                    counter1.increase();
                }
            });
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 5000; i++) {
                    counter1.increase();
                }
                // 多个线程去调用这个increase方法，其实就是针对这个Counter对象counter1来进行加锁
                // 如果一个线程t1获取到了该对象counter1的锁，那么另一个线程t2就要等到counter1对应的锁开了后（t1线程执行完该锁里的内容——++操作）t2才能执行++操作
                // 此时++操作相当于是成为了一个整体（相当于一个指令，当一个线程再执行这个加锁的整体的指令的时候，另一个线程只能阻塞等待）
            });
            t1.start();
            t2.start();
            t1.join();
            t2.join(); // 确保线程t1和线程t2都执行完了，main主线程再接着执行——输出count
            System.out.println(Counter.count); // 输出10000
        }
    }

形式三、

![018a085ce216489fbb08810cdaf4749a.png][]

![5b3d92c51476453ba56468f8a16bf76d.png][]

当我们给不同的对象上锁后，如果用住房来比喻

> 不同的房间相当于是不同的对象，不同的线程相当于是不同的客人
> 
> **如果房间1住了客人A，那么房间1就上了锁，客人B就需要等客人A不再住房间1（开了锁）然后客人B才能住房间1；或者客人B住其他的房间（其他的对象，没上锁的）**

package Thread;
    // 测试线程竞争，对锁的竞争
    public class demo7777 {
        public static Object object1 = new Object();
        public static Object object2 = new Object();
        public static void main(String[] args) {
            Thread t1 = new Thread(() -> {
                // 针对object1对象进行加锁，加锁操作是针对某一个对象来进行的
                synchronized (object1) {
                    System.out.println("t1线程start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1线程finish");
                }
            });
            t1.start();
            Thread t2 = new Thread(() -> {
                synchronized (object1) {  // 针对object1对象来进行加锁操作
                    System.out.println("t2线程start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t2线程finish");
                }
            });
            t2.start();
        }
    }

![c5a282fd9ba745d9baa072a4834e4339.png][]

![3b5b44a9a8894c2c84acd50f70e1571d.png][]

我们上面就是两个线程t1和t2同时对object1这个对象进行了加锁，然后t1与t2直接就产生了竞争。从上述代码的实现过程中我们也可以看到，等到t1线程执行完了后，t2线程才开始执行。

但如果是两个线程对不同的对象进行加锁，则没有竞争（就像两个客人（两个线程）住不同的房间（不同的对象）当然不会发生竞争。

package Thread;
    // 测试线程竞争，对锁的竞争
    public class demo7777 {
        public static Object object1 = new Object();
        public static Object object2 = new Object();
        public static void main(String[] args) {
            Thread t1 = new Thread(() -> {
                synchronized (object1) { // 针对object1对象来进行加锁，加锁操作是针对一个对象来进行的
                    System.out.println("t1线程start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t1线程finish");
                }
            });
            t1.start();
            Thread t2 = new Thread(() -> {
                synchronized (object2) { // 针对object2对象进行加锁
                    System.out.println("t2线程start");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    System.out.println("t2线程finish");
                }
            });
            t2.start();
        }
    }

![1c2e26aa617846a49be3f3028124b543.png][]

**对上面补充一下：**

![eebd49d636f44fffb0555a40c2614ef9.png][]

--------------------

### ?优化过程中所造成的线程不安全 ###

上述三个是造成线程安全问题的的主要原因，除此之外。在编译器/JVM/操作系统对程序优化的过程中也会好心办坏事，造成线程不安全

#### 1、内存可见性引起的安全问题 ####

![38b0b7352ae140708ba8f832fee4632f.png][]

**分析**

![92d8ec09f4b1487b8c387b7cbc6743e0.png][]

**?栗子**

![219a457d35af44cfaf59912e50ab28bd.png][]

为什么会这种情况呢？

> 但我们的t1、t2创建好了后，操作系统内存对我们这两个线程进行随机调度执行。那么我们的t1线程在执行过程中就不断地从内存中读取flag的值，然后进行判断**。那么就有可能t1线程在执行了好长一会后，t2才执行、输入了一个整数&&改变了flag值。**

> 是操于作系统就发现，怎么回事，这个flag值一直也没有改变，那么t1线程一直不断地从内存中读取flag的值，这样的效率是很低的。**于是操作系统就对这种情况进行了优化，t1在第一次从内存中读取flag的值后就不再反复的从内存中读取了，接下来只是不断地进行判断**——也就是说：在t2线程把flag的值更改了后，t1线程并没有成功读取到更改后的flag值。

**解决方案**

![8d12571d064d465ea71d0932e08d5164.png][]

![9901ceb190c44a99998d30d438def979.png][]

**再补充一个栗子**

![7422692d671e4685ba90a490f29290ab.png][] ![7abc5933198540928fb6a1d278876601.png][]

--------------------

#### 2、指令重排序引起的安全问题 ####

![6dc763522eb54fcab6eb83148f5b7285.png][]

比如说接下来我要干三件事

> **1、去超市闲逛**
> 
> **2、 回家**
> 
> **3、去超市买菜**

如果我安装1->2->3的顺序来执行，是不是很傻、很浪费时间。在程序执行的过程中也是如此，通过顺序的改变和调整就可以达到优化的效果。

但有时候顺序是不能随便改变的

![21dbc2d096d444b2acaf45abc36309ec.png][]

编译器 / JVM / 操作系统 优化优化着，还优化出BUG了，那为啥还要有优化呢？

> **因为不同的程序员的水平差异是非常大的，通过优化，对我们的程序执行效率可能会有翻倍的提升！！！服务器启动的时候，如果加上编译器优化，启动时间10min！但如果关闭优化，启动时间 > 30 min！！！**

所以说，不管怎么优化，我们的大前提是要保证程序的逻辑是不变的！我们是希望在逻辑不变的前提下，通过一些优化的操作来提升效率、提高速度！！！

补充一下在单线程下，保证逻辑不变很容易做到。但在多线程环境下，想有在不改变逻辑的前提下优化就变得很困难了——所以才会出现内存可见性问题、指令重排序问题

## 三、总结 ##

![7d0ad44f06884f148d1df73bde4ecedb.png][]

### 对集合类安全性的一点补充： ###

#### 线性安全的集合类 ####

>  *  Vector：只要是关键性的操作，方法前面都加了synchronized关键字，来保证线程的安全性
>  *  Hashtable：使用了synchronized关键字，所以相较于Hashmap是线程安全的。
>  *  ConcurrentHashMap:使用锁分段技术确保线性安全，是一种高效但是线程安全的集合。
>  *  Stack：栈，也是线程安全的，继承于Vector。

#### 线性不安全的集合类 ####

>  *  Hashmap
>  *  Arraylist
>  *  LinkedList
>  *  HashSet
>  *  TreeSet
>  *  TreeMap

Hashmap：HashMap在put操作的时候，如果插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是resize，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致在get时会出现死循环，所以HashMap是线程不安全的。

Arraylist： List 对象在做 add 时，执行 Arrays.copyOf 的时候，返回一个新的数组对象。当有线程 A、B… 同时进入 grow方法，多个线程都会执行 Arrays.copyOf 方法，返回多个不同的 elementData 对象，假如，A先返回，B 后返回，那么 List.elementData ==A. elementData,如果同时B也返回，那么 List.elementData ==B. elementData,所以线程B就把线程A的数据给覆盖了，导致线程A的数据被丢失。

LinkedList：与Arraylist线程安全问题相似，线程安全问题是由多个线程同时写或同时读写同一个资源造成的。

HashSet：底层数据存储结构采用了Hashmap，所以Hashmap会产生的线程安全问题HashSet也会产生。

SimpleDateFormat： 对象是线程不安全的

[f35358cba8b1408ab904ad1246d58175.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/4bd49bd77cea48eb9d4f9fe58af263f7.png
[0e75d685db6f419586e815248f939b3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/101401f1474b465c99c5988b9d8cb7c7.png
[af5cc27030cf487a81d2cb674906c712.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/c52e74c26bb649cead2a608bec12fba5.png
[6749c1d243dd4139ae1d71bb13238fc6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/54b83d3ef97945d5929b3edcccc59dbd.png
[15ac811137144c5abc01c49068c5a363.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/2d5b80733687474fb40943f85a286845.png
[2cb8f0784e024604a6c09d38882f0676.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f3dd15747f3a4540952d97552bcd1bdd.png
[82dc94c8208f479e86508569793a36be.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/be95a9935916426e89db833b5fad0cd5.png
[6f7db6896d464b26a07d7eccc52b66dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/6bd6cfa1d8cb43a1ada5abac8321e873.png
[018a085ce216489fbb08810cdaf4749a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/643fd78da1c34b7c90ecb6d3b374e82f.png
[5b3d92c51476453ba56468f8a16bf76d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/8d0ee90b44d14a9c93d53fe07e9b057f.png
[c5a282fd9ba745d9baa072a4834e4339.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/94dfe332135048f68e0c16bd8c3195bb.png
[3b5b44a9a8894c2c84acd50f70e1571d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/728e5bfcb08f47eaae516addae96c6ae.png
[1c2e26aa617846a49be3f3028124b543.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/1e8eff8387b54e868a5b7976ef5bea02.png
[eebd49d636f44fffb0555a40c2614ef9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/ec2769a5f5364c15be7f0ea03a965d24.png
[38b0b7352ae140708ba8f832fee4632f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/bc6150b7d3cc406d8957e65956abd202.png
[92d8ec09f4b1487b8c387b7cbc6743e0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/49d00b922603442294d0afc6dd2ce7c0.png
[219a457d35af44cfaf59912e50ab28bd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/d12c08dd7817498ab2aafd8c48206822.png
[8d12571d064d465ea71d0932e08d5164.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/f9a9d9757aaa4ad49075cdac49182fd2.png
[9901ceb190c44a99998d30d438def979.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/76023628472e421eb8207da373037369.png
[7422692d671e4685ba90a490f29290ab.png]: https://img-blog.csdnimg.cn/7422692d671e4685ba90a490f29290ab.png
[7abc5933198540928fb6a1d278876601.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/76781ab714db4678a3bcad92df9002b6.png
[6dc763522eb54fcab6eb83148f5b7285.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/7785fd6e154f4742b428f7c13683ab0e.png
[21dbc2d096d444b2acaf45abc36309ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/a8a6d0adb4534acda8235d748230fac8.png
[7d0ad44f06884f148d1df73bde4ecedb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/579c648ce6614b4db5d3f509389fc962.png