Java线程安全

丶chuchu丶

已于 2022-04-05 14:32:52 修改

阅读量1.1k

点赞数 1

分类专栏： java_learning 文章标签： java

于 2022-03-26 19:17:11 首次发布

本文链接：https://blog.csdn.net/m0_56620669/article/details/123755699

版权

java_learning 专栏收录该内容

18 篇文章 1 订阅

订阅专栏

引例

先来一个引例 : 创建两个线程对同一个变量进行自增50000次

class Counter {
    // 这个 变量 就是两个线程要去自增的变量
    public int count;

    public void increase() {
        count++;
    }
}

public class Demo1 {
    private static final Counter counter = new Counter();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50000; i++) {
                counter.increase();
            }
        });
        t1.start();
        t2.start();

        // 必须要在 t1 和 t2 都执行完了之后, 在打印 count 的结果.
        // 否则, main 和 t1 t2 之间都是并发的关系~~, 导致 t1 和 t2 还没执行完, 就先执行了下面的 打印 操作
        t1.join();
        t2.join();

        // 在 main 中打印一下两个线程自增完成之后, 得到的 count 结果~~
        System.out.println(counter.count);
    }
}

运行结果却不是100000. 这是为什么?

先了解一下自增的 count++ 这条指令在CPU中干了什么?

把内存中的count加载到CPU寄存器中
把寄存器中的值给+1
把寄存器的值写回到内存中的count中

但是两个线程在同时执行,所以上面三个步骤,顺序上会充满随机性.

所以当两个线程同时执行第二步时,实际上只进行了一次自增.

不安全的情况

这里再来讨论一下另外的情况:(我们假设count为0,两个线程都给count++)

第一种:

t1先拿到值,自增后直接保存, 此时 t2 拿到的值就是正确的

第二种:

t1 拿到0, t2也拿0 .注意,此时它们拿的是各自的

t2 先自增为1, 然后返回到 count,此时count为1

t1 再自增,将自增的值返回给count,所以此时的count还是1

两个线程只是各自把自己自增的值给了count,没有增加两次

第三种:

t2拿到0, t1也拿到0, t2自增为1, 保存, t1 也自增, 保存

这种情况还是自己给count自己增加的值,依旧线程不安全

第四种:

t1 拿到0再自增, 但注意此时 t1 没有保存, 所以 t2 拿到还是0

t2 再自增, 此时 t1 才保存, 接着 t2 保存

不难发现,又把 1 保存了两遍,所以依旧线程不安全.

解决办法

此时要想避免这种线程不安全问题,就要开始重点了 -- 加锁

像下面的样子,我先给 t1 在 load 和 save 操作之间加锁

再给 t2 也上锁, 但是锁被占用了, 只能等 t1 解了锁, t2 才能运行

这样虽然结果对了, 但是变成了串行, 也就增加了隔离性, 效率变低了.

加锁

此时打开IDEA,我们来写加锁操作.

class Counter {
    // 这个 变量 就是两个线程要去自增的变量
    public int count;

    synchronized public void increase() {
        count++;
    }
}

很简单, 直接给自增方法前写上synchronized进行加锁

这样子进方法就加锁, 出方法才会解锁

一个线程尝试加锁成后, 其他线程尝试加锁便会进入阻塞状态

内存可见性

规定一个线程频繁的去读取一个数, 由于编译器优化的问题

这个线程会偷懒到寄存器中读,如果有线程此时修改了值,就会导致读的线程读到了一个错误数据

用代码来实现如下:

public class Demo2 {
    private static int isQuit = 0;

    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            while (isQuit == 0) {
                //不停地读
            }
            System.out.println("循环结束! t 线程退出!");
        });
        t.start();

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个 isQuit 的值: ");
        isQuit = scanner.nextInt();//进行了一次写操作,但是线程感知不到
        System.out.println("main 线程执行完毕!");
    }
}

这样的情况我们是不知道的, 所以也叫做内存可见性的问题

如何避免?