线程的安全问题【重点】

风华瑞雪年

已于 2022-08-20 21:27:49 修改

阅读量327

点赞数

分类专栏：操作系统文章标签： java

于 2022-08-19 17:54:50 首次发布

本文链接：https://blog.csdn.net/qq_50977605/article/details/126420055

版权

操作系统专栏收录该内容

8 篇文章 0 订阅

订阅专栏

1.线程之间是抢占式执行的（根本原因，万恶之源）

前言

线程安全是多线程里面最核心的话题，也是和实际工作最相关的话题，不管是工作还是学习，都应该重点掌握。

什么是线程安全？【经典面试题】

为了更好的理解多线程安全问题，我们先看一个例子

public class ThreadDemo15 {
    static class Counter{
        public int count=0;
        public void increase(){
            count++;
        }
    }
    static Counter counter=new Counter();
    public static void main(String[] args) throws InterruptedException {
        //此处创建两个线程，分别对count自增5w次
        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        t1.start();
        Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };
        t2.start();
        t1.join();
        t2.join();
        System.out.println(counter.count);
    }
}

运行结果每次都不一样

而我们真正想要的结果其实是10w

那么哪里出了问题呢？

我们可以判断这大概率和多线程并发执行相关，而且通过验证，确实是这样

验证过程

public class ThreadDemo15 {
    static class Counter{
        public int count=0;
        public void increase(){
            count++;
        }
    }
    static Counter counter=new Counter();
    public static void main(String[] args) throws InterruptedException {
        //此处创建两个线程，分别对count自增5w次
        Thread t1=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 100000; i++) {
                    counter.increase();
                }
            }
        };
        t1.start();
        /*Thread t2=new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 50000; i++) {
                    counter.increase();
                }
            }
        };*/
        //t2.start();
        t1.join();
        //t2.join();
        System.out.println(counter.count);
    }
}

这种情况，我们称之为“线程不安全”

为了解决这个问题，我们需要分析程序执行的过程

首先我们需要知道count++的详细过程

count++的详细过程

共分为三个步骤：

1.把内存中的值读取到CPU中（load）

2.执行++操作（add）

3.把CPU的值写回到内存中(save)

刚刚是一个线程执行count++操作，但如果是两个线程并发执行count++操作，那么就容易出问题

我们需要知道的是操作系统调度线程的时候是“抢占式执行”的方式，也就是竞争的关系，某个线程什么时候上CPU执行，什么时候切换出CPU，是完全不确定的。而且另一方面，两个线程在两个不同的CPU可以并发执行。因此，两个线程的执行顺序是完全不可预测的。

我们先假设两个线程针对一个变量进行++操作，我们需要知道count++的操作并不是完全三步都要执行完，也可能是线程1只执行完load，线程2把三步都执行完，线程1再执行后面的两步，此时，算出的结果就会出问题，假设内存中初始值为0，线程2执行完count++后内存中的值变为了1，线程1把后面两步都执行完之后，内存中的值还是1，这是出现了问题，因为我们的两个线程执行了两次count++操作，内存中的结果按理来说应该是2。而且这只是出现问题的其中一种情况。

只有串行执行的时候才不会出现这样的问题。