当前位置：首页 > news >正文

并发基础—三大问题：可见性、原子性、有序性

news 来源：原创 2025/5/10 19:03:45

文章目录

可见性
原子性
有序性（指令重排）
- 经典的指令重排案例：单例模式的双重检查锁
- volatile和synchronize都可以保证有序性
- 并发压测工具Jcstress证明指令重排会在多线程下出现问题（了解）
- CPU缓存分为三个级别：L1、L2、L3
- 寄存器
- 缓存和寄存器的区别
- - JMM（java memory modle）

可见性

原子性

并发编程时，当一个线程对共享变量的修改操作进行到一半时，另一个线程也可能来操作共享变量，这时就会干扰前一个线程的操作，这也就是原子性问题。

public class AtomicDemo {
    private static int num = 0;
    public static void main(String[] args) {
        List<Thread> list = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    num++;
                }
            });
            list.add(thread);
            thread.start();
        }
        list.forEach(e -> {
            try {
                e.join();
            } catch (InterruptedException ex) {
                ex.printStackTrace();
            }
        });
        System.out.println(num);
    }
}

上面代码的运行结果不一定是5000,原因分析如下：
i++编译后对应的JVM指令实际有4条，当只执行了部分操作时，另一个线程同时操作i变量，就会出现原子性问题
在这里插入图片描述

有序性（指令重排）

指令重排：为了保证程序的执行效率，在不影响正确性的前提下，编译器和CPU会对程序中代码进行优化，即指令重排序

指令重排必须保证单线程情况下程序的运行结果是正确的
指令重排在多线程下可能会影响程序运行结果的正确性。

经典的指令重排案例：单例模式的双重检查锁

volatile和synchronize都可以保证有序性

synchronize：保证了只有一个线程在操作同步代码块内的代码，而指令重排在单线程的情况下运行结果是正确的

并发压测工具Jcstress证明指令重排会在多线程下出现问题（了解）

<dependency>
    <groupId>org.openjdk.jcstress</groupId>
    <artifactId>jcstress-core</artifactId>
    <version>0.7</version>
    <scope>test</scope>
</dependency>

/**
* 需求：测试指令重排导致程序结果异常情况
* 方法test2中,有可能 flag=true先执行，而num=2后执行，位置交换导致出现方法test1结果r.r1=0
*/
@JCStressTest
//表示对输出结果的处理  Expect.ACCEPTABLE 可以接收的结果
@Outcome(id = {"1", "4"}, expect = Expect.ACCEPTABLE, desc = "ok")
//Expect.ACCEPTABLE_INTERESTING 表示可以接收，并感兴趣的结果
@Outcome(id = "0", expect = Expect.ACCEPTABLE_INTERESTING, desc = "danger")
@State
public class jcstress {
    int num = 0;
    boolean flag = false;
    //线程1执行的代码
    @Actor
    public void test1(I_Result r) {
        if (flag) {
            r.r1 = num + num;
        } else {
            r.r1 = 1;
        }
    }
    //线程2执行的代码
    @Actor
    public void test2(I_Result r) {
        num = 2;
        flag = true;
    }
}

在这里插入图片描述

CPU缓存分为三个级别：L1、L2、L3

CPU的运算速度和内存的访问速度相差比较大，导致CPU每次操作内存都需要耗费大量的等待时间，于是CPU和内存直接增加了缓存设计。

（1）L1（一级缓存）是最接近CPU的，三个缓存中它容量最小，速度最快，每个物理内核上都有个一级缓存L1
（2）L2（二级缓存）速度比L1慢，比L3快，一般情况下每个物理核上都有一个独立的L2
（3）L3（三级缓存）是三个缓存中最大的，同时也是速度最慢的，同一个CPU插槽上的核共用一个三级缓存

寄存器

CPU和一级缓存之间还有寄存器，CPU经常使用同一内存地址的某数据时，为减少频繁读取的消耗，就会把该数据存储到寄存器。

缓存和寄存器的区别

（1）缓存是把CPU需要的数据提前缓存起来，减少读取的消耗，但不一定是经常使用的
（2）寄存器是把CPU经常使用的同一内存地址的数据缓存起来，减少读取消耗
在这里插入图片描述

JMM（java memory modle）

java内存模型和java内存结构不是一回事，java内存模型用于多线程读写共享数据时，保证共享数据的可见性、有序性、原子性，主要是通过synchronize、volatile两个关键字来实现

（1）主内存：主内存是所有线程都能访问，所有共享变量都存储在主内存—方法区和堆
（2）工作内存：每个线程都有自己的工作内存，只存储该线程需要用到的共享变量的副本，线程对变量的所有操作都是工作内存完成的，而不是直接读写主内存的变量，不同线程之间也不能相互访问工作内存中的变量。
（3）jMM内存模型和硬件内存不是一回事，它是一个抽象的概念，不管是工作内存的数据还是主内存的数据，即可能存储到内存，也可能存到CPU的三级缓存或者寄存器中。
在这里插入图片描述