线程安全与volatile关键字

系统管理员 2024-03-24 08:41 109阅读 0赞

![91184d50cd3745729857375f2d67c694.gif][]

>  *  **博主简介：努力的打工人一枚**
>  *  **博主主页：[@xyk：][xyk]**
>  *  **所属专栏: [JavaEE初阶][JavaEE]**

线程都能带来哪些风险？想了解线程安全问题吗？请仔细阅读本篇文章，将详细带你学习什么是线程安全！！！

##  ##

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

**目录**

一、什么是线程安全和线程不安全？

二、线程不安全的原因

三、如何解决线程不安全问题

四、内存可见性问题-volatile

4.1volatile详解

4.2“房子装修”

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

##  ##

## 一、什么是线程安全和线程不安全？ ##

> **简单来说，某个代码，在多线程环境下执行，会出bug，就叫做线程不安全。**
> 
> **线程安全：如果多线程环境下代码运行的结果是符合我们预期的，即在单线程环境应该的结果，则说这个程序是线程安全的。**
> 
> 本质上是因为线程之间的调度顺序是不确定的，那么我来举例说明一下：
> 
>     class Counter{
>        private int count = 0;
>     
>        public void add(){
>           count++;
>       }
>     
>       public int get(){
>            return count;
>       }
>     }
>     
>     class ThreadDemo{
>         public static void main(String[] args) throws InterruptedException {
>             Counter counter = new Counter();
>             Thread t1 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     counter.add();
>                 }
>             });
>     
>             Thread t2 = new Thread(() -> {
>                 for (int i = 0; i < 50000; i++) {
>                     counter.add();
>                 }
>             });
>     
>             t1.start();
>             t2.start();
>     
>             t1.join();
>             t2.join();
>     
>             System.out.println(counter.get());
>         }
>     }
> 
> 上述代码是俩个线程针对同一个变量，各自自增5w次，那么结果会是什么？
> 
> 是10w吗？还是其他？下面来看结果：
> 
> ![0102d9dcb5f846d8b40e4d880847d4ed.png][]

> 此时会疑惑？？？为什么不是正常预期中的结果呢？这是因为由多线程引起的bug，线程不安全问题！！！
> 
> 那么为什么会出现上述情况呢，和线程的随机调度密切相关！！！
> 
> count++操作，本质上是三个cpu指令构成
> 
> **1.load，把内存中的数据读取到cpu寄存器中**
> 
> **2.add，把寄存器中的值，进行+1运算**
> 
> **3.save，把寄存器的值写回到内存中**

初始状态：

![c4fed5c8ba2d49709a354c5004dc44a7.png][]

由于多线程调度顺序是不确定的，实际执行过程中，这俩线程的++操作实际的指令排列顺序就有很多种可能！！！如下图三种：

![80583f22f8624f77b023ddd7e9a3690f.png][]

![71a4eb22e7af46dd878beb7ee652972f.png][]

![9460fcc298f24012bb272e156c68f28d.png][]

> 那么不同排列顺序下，执行结果，可能是截然不同的！！！

那么上面代码的线程执行顺序可能是：

![3e261fed21c140b69630f5f92c3611ad.png][]

![58fd52cc422641b994b5201886d1bd3b.png][]

> 此时发现，俩个线程自增俩次，结果是1，说明bug出现了，其中一次的自增的结果，被另一次给覆盖了！！！
> 
> **由于线程的调度顺序是随机的，无序的，出现bug之后，得到的结果一定是<=10w**

那么如果要是正确的结果，俩个线程，各自自增，此时是没bug 的，那么执行顺序应该是：

![c139077298a54013afabfc77a058b222.png][]

![1e22cffef8dd41018466d84ab84c6f13.png][]

> t1和t2是俩个线程，可能是运行在不同的cpu核心上，也可能是运行在同一个cpu核心上(但是是并发的)

> 那么归根到底，线程安全问题，全是因为线程的无序调度，导致了执行顺序不确定，结果就不一致了！！！

## **二、线程不安全的原因** ##

> 1.  **抢占式执行**
> 2.  **多个线程修改同一个变量**
> 3.  **修改操作，不是原子的（不可分割的最小单位，成为原子，像上述的++操作，不是原子的，里面可以拆分为三个操作，load，add，save，某个操作，对应单个cpu指令，就是原子的）**
> 4.  **内存可见性(可见性指, 一个线程对共享变量值的修改，能够及时地被其他线程看到)**
> 5.  **指令重排序**

## 三、如何解决线程不安全问题 ##

> 需要从原因入手，能否让count++变成原子的呢？
> 
> 那么加锁可以有效的使count++变成原子操作，锁，就能够起到保证“原子性”的效果。
> 
> 一旦某个线程加锁了之后，其他线程也想加锁，就不能之间加上，就需要一直等到拿到锁的线程释放锁了为止，那么java中如何加锁？

> 使用**synchronized关键字**，直接使用这个关键字来实现加锁效果，锁有俩个核心操作，加锁和解锁：使用代码块来表示
> 
> ![1111368ee6814c52b1703b22452179a1.png][]
> 
>  进入synchronized修饰的代码块的时候，就会触发加锁，出了synchronized代码块，就会触发解锁。
> 
> 其中的this表示锁对象，表示对哪个对象加锁，如果俩个线程针对同一个对象加锁，此时就会出现“锁竞争”(一个线程先拿到锁，另一个线程阻塞等待)，如果俩个线程针对不同线程加锁，就不会出现锁竞争，各自获取各自的锁
> 
> ![319276ce24a14502af64266a1a71553d.png][]
> 
> **上述代码中，这里线程是在竞争同一个锁对象，就会产生锁竞争，此时就可以保证++操作是原子的，不受影响了**

![56f8ad2602fb4b678116aafac7219c60.png][]

>  **由于t1已经lock了，t2再尝试进行lock，就会出现阻塞等待的情况，此时就可以保证t2的load一定在t1的save之后，此时计算的结果就是线程安全的，加锁本质上是把并发的变成了串行的。**
> 
> 上述代码，一个线程的工作应该是：
> 
> **1.创建i**
> 
> **2.判断i<50000**
> 
> **3.调用add**
> 
> **4.count++**
> 
> **5.add返回**
> 
> **6.i++**

**下面是加锁之后的代码：**

class Counter{
       private int count = 0;
    
       public void add(){
           synchronized (this) {
               count++;
           }
       }
    
      public int get(){
           return count;
      }
    }
    
    class ThreadDemo{
        public static void main(String[] args) throws InterruptedException {
            Counter counter = new Counter();
            Thread t1 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            });
    
            Thread t2 = new Thread(() -> {
                for (int i = 0; i < 50000; i++) {
                    counter.add();
                }
            });
    
            t1.start();
            t2.start();
    
            t1.join();
            t2.join();
    
            System.out.println(counter.get());
        }
    }

![561e839cc1a542a9846b8db8152dc2dc.png][]

> **加锁也可以直接给方法加锁，用synchronized修饰，如果synchronized修饰静态方法，就是给类对象加锁**
> 
> ![57a5ead3fb76486b86555ab072b235c2.png][]
> 
> 还可以指定一个锁对象进行加锁：
> 
> ![7a53dc7fbf8a48daa7e6afa08d5b4bef.png][]

## 四、内存可见性问题-volatile ##

> 先写个bug出来：  
> 
> 
>     public class ThreadDemo1 {
>          public static int flag = 0;
>     
>         public static void main(String[] args) {
>             Thread t1 = new Thread(() -> {
>                 while (flag == 0) {
>                     // 空着
>     //                try {
>     //                    Thread.sleep(10);
>     //                } catch (InterruptedException e) {
>     //                    e.printStackTrace();
>     //                }
>                 }
>                 System.out.println("循环结束! t1 结束!");
>             });
>     
>             Thread t2 = new Thread(() -> {
>                 Scanner scanner = new Scanner(System.in);
>                 System.out.println("请输入一个整数: ");
>                 flag = scanner.nextInt();
>             });
>     
>             t1.start();
>             t2.start();
>         }
>     }
> 
> **预期效果：t1通过flag ==0 作为条件进行循环，初始情况，将进入循环；t2通过控制台输入了一个整数，一旦用户输入了非0的值，此时t1的循环就会立即结束，从而t1线程退出！！**
> 
> **实际效果：输入非0的值之后，t1线程并没有退出，循环没有结束，仍然在运行！！**
> 
> ![c74f5a6ff78e4f77b605fc5f0861cad2.png][]
> 
> **实际效果 != 预期效果**

> 那么为什么会有这个问题？内存可见性的锅，
> 
> while循环，flag==0，load从内存读取数据到cpu寄存器，cmp比较寄存器里的值是否是0。
> 
> 此处的load时间开销远远高于cmp！！！
> 
> 于是编译器就发现：
> 
> **1.load的开销很大**
> 
> **2.每次load的结果都一样**
> 
> **此时编译器就做了一个非常大胆的操作，把load就给优化掉了，只有第一次执行了load，后续都只cmp，不load！！！---这是编译器优化的手段，此时结果就发生了变化，出现了误判！！!**

> 编译器优化，就是能够智能的调整你的代码执行逻辑，保证程序结果不变的前提下，通过加减语句，通过一系列操作，让整个程序执行的效率大大提升

> **那么我们为了解决这个问题，加上volatile关键字之后，此时编译器不再优化，此时编译器就能够保证每次都从内存中读取flag变量的值**![296012895ebb4e33bb21ef14d8822c2f.png][]
> 
> ![11a36033b1f14dc4b6c527062e01b7cb.png][]

#### 4.1volatile详解 ####

> **volatile不保证原子性，volatile适合的场景是一个线程读，一个线程写的情况，synchronized则是多个线程写。**
> 
> 上面讲述了什么叫保证内存可见性，**那么volatile还有另外一个效果，就是禁止指令重排序，所谓指令重排序，也是编译器优化的策略，调整了代码的执行的顺序，让程序更高效，前提是保证整体逻辑不会变。**

> 举个例子：
> 
> 假如小明去超市买菜，按照出口->入口的方式去买
> 
> ![c4e3ad6b880c46cb8ce9fe1f6adb3071.png][]
> 
> 那么如果调整顺序，先买入口的再买出口的，执行效果不变，效率提高了。那么使用volatile就可以禁止指令重排序，大部分情况下对于指令重排序都是正确的，但是加上volatile也什么影响哦！

#### 4.2“房子装修” ####

> 如果是这样一个代码：
> 
> ![4020b32935aa47ee9d02125206c8bda7.png][]
> 
> ![7430258408fc416b9086b9c4769ffd77.png][]
> 
>  大体可以分成三部操作：
> 
> 1.申请内存空间
> 
> 2.调用构造方法（初始化内存的数据）
> 
> 3.把对象的引用赋值给s（内存地址的赋值）
> 
> 这个操作就像是买房子：
> 
> ![dfceb6d07c854de7a5e4631622c027b2.png][]
> 
> 先装修了，再拿到钥匙，就叫做“精装修房”；先拿到钥匙，再装修，房子就叫做“毛坯房”
> 
> 假设俩个线程开始执行，t1按照1 3 2的顺序执行，最后装修，当t1执行完1 3 之后，即将执行2的时候，t2开始执行，由于t1的3已经执行过了，这个引用就非空了！！！
> 
> t2线程就尝试调用s.learn()，由于还是个毛坯房，没有初始化过，此时learn就可能会出现bug！！

[91184d50cd3745729857375f2d67c694.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/d47fb5b6713e41aab79bd4cce4ce47e5.png
[xyk]: https://blog.csdn.net/asad21654864?spm=1000.2115.3001.5343
[JavaEE]: https://blog.csdn.net/asad21654864/category_12243955.html?spm=1001.2014.3001.5482
[0102d9dcb5f846d8b40e4d880847d4ed.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/20ccf4213895401eb56382b8b195439b.png
[c4fed5c8ba2d49709a354c5004dc44a7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/140355bedd684bcf9d7a24169a217e09.png
[80583f22f8624f77b023ddd7e9a3690f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/9ea28c0c4fa14e4a823d7ded5c181971.png
[71a4eb22e7af46dd878beb7ee652972f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/ce77d91566ae4c6e904f6c091eee63ea.png
[9460fcc298f24012bb272e156c68f28d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b4036e0326294a328f4fb841f645b839.png
[3e261fed21c140b69630f5f92c3611ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/eb8cc70cea844070b17ec65fa67d5dd8.png
[58fd52cc422641b994b5201886d1bd3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/dec507077f06432989aa7384f1fb7e12.png
[c139077298a54013afabfc77a058b222.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3b59f1939e8344a6a682a4a1bdf0d7c8.png
[1e22cffef8dd41018466d84ab84c6f13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/099ff5160fe948368c4d7d0e7f518fcb.png
[1111368ee6814c52b1703b22452179a1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/3998f456c0474a65a91257e2f4dfe5df.png
[319276ce24a14502af64266a1a71553d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/c76f279975394fb4a5f79a060bf6f00e.png
[56f8ad2602fb4b678116aafac7219c60.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/178ad20ad1da42fa8436bec78c4453a1.png
[561e839cc1a542a9846b8db8152dc2dc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b1c89d9dabd54fd68671283cc0d4602c.png
[57a5ead3fb76486b86555ab072b235c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/8a2feb86bb7a485da5d7ea58a99b4e5b.png
[7a53dc7fbf8a48daa7e6afa08d5b4bef.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/7c81ce774c8c4a759516761bf2315860.png
[c74f5a6ff78e4f77b605fc5f0861cad2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/6b7471e6c5ad4f23a07ef6a9a47cbd6f.png
[296012895ebb4e33bb21ef14d8822c2f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/ee1d8857d6114d9e8c3ee867b762c1da.png
[11a36033b1f14dc4b6c527062e01b7cb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/bdc283864ea84828a79ffed0771762b4.png
[c4e3ad6b880c46cb8ce9fe1f6adb3071.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/a0e5f3385f9d4724950af4879527a1ea.png
[4020b32935aa47ee9d02125206c8bda7.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b33c94d0871f4d668584c4f2ac802bd7.png
[7430258408fc416b9086b9c4769ffd77.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/b1f6cd1977fc4eb48d3d13db801c6d01.png
[dfceb6d07c854de7a5e4631622c027b2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/24/06122e13ce4a4a938247d55248b8a2f3.png