并发编程核心问题 - 可见性,有序性, 原子性

本文链接：https://blog.csdn.net/xx12321q/article/details/124861925

CAS(Compare-And-Swap)

ABA问题

可见性问题

在如今的多核CPU中 , 由于CPU与内存存在速度差异, 所以每个核都有自己的缓存, 缓存是私有的, 这就导致CPU缓存与内存中的数据可能会出现不一致的情况

CPU在自己的缓冲区拿到数据进行写操作之后, 并不会立刻将这个数据更新回内存中, 如果此时来了另一个线程, 它此时应该读入的是上一个线程修改后的值, 但由于不是即时更新的,此时第二个线程拿到的还是原本的值, 也就是说, 这两个线程之间对此变量操作是不可见的, 这就是可见性问题

如上图, 内存中有一个共享变量a=0, 此时线程1 先进入, 操作之后 a=1, 但此时还没来及将这个值更新回内存, 线程2就将 a =0又读入了它里面, 此时两边最终更新的值都为1(原本应为2)

此问题可通过volatile 关键字解决 , 在后面有序性中提到

有序性问题

编译器为了优化性能, 可能会重排我们的程序结构, 改变语句执行的先后顺序, 那么我们的有些程序肯定是不能被打乱执行的, 必须要按指定的顺序执行

例如像上面的这种情况, 编译器会做以上的优化,进行指令重排, 但有时我们的程序并不支持这样做, 那么此问题如何来解决呢 ? 同样也是使用volatile 关键字解决

volatile 关键字

一旦一个共享变量（类的成员变量、类的静态成员变量）被 volatile 修饰之后：

1. 保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。

2. 禁止进行指令重排序。

3. volatile 不能保证对变量操作的原子性。(原子性后面讲述)

我们说 volatile 关键字可以直接解决可见性问题和有序性问题, 如下:

public class ThreadDemo implements Runnable {
    /*
       volatile 修饰的变量,在一个线程中被修改后,对其它线程立即可见
       禁止cpu对指令重排序
     */
    private volatile boolean flag = false;//共享数据

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        this.flag = true;//让一个线程修改共享变量值
        System.out.println(this.flag);
    }

    public boolean getFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}

public class TestVolatile {

    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();
        Thread t = new Thread(td);//创建线程
        t.start(); //启动线程

        //main线程中也需要使用flag变量
        while (true) {
            if (td.getFlag()) {
                System.out.println("main---------------");
                break;
            }
        }
    }
}

在上述代码中, 有一个共享变量 flag = false , 此时我们单独开启一个线程, 在此线程中将flag改成 true , 在main线程中用 while死循环监视flag , 此时如果没有volatile关键字修饰这个变量, 由于可见性问题 , 那么main线程中的死循环将不会停止, 但由于volatile关键字的存在, 使得另一个线程修改了flag的值之后对于main线程是立即可见的, 此时会结束死循环(感兴趣可以复制上面代码, 取消volatile关键字自己执行看看效果)

原子性问题

最后我们来看这个原子性问题 , 因为它的解决方法和前两个不一致

原子的意思代表着——“不可分”; 一个或多个操作在 CPU 执行的过程中不被中断的特性,我们称为原子性

当我们的若干个操作是一个整体时, cpu由于线层切换可能会将我们这若干个操作分开去执行, 这样就会导致出现问题, 最著名的问题就是 :

i ++是安全的吗?

在多线程的并发下, 此操作是不安全的, 它不是一个原子操作, i ++ 可分为三步三条 CPU 指令 :指令 1：首先，需要把变量 count 从内存加载到工作内存；指令 2：之后，在工作内存执行 +1 操作；指令 3：最后，将结果写入内存;

那么CPU会将这三条指令依次执行吗? 并不会, 由于线程切换, 是没办法保证 i++操作的原子性的, 如下图

线程A 读入count之后, 线程B也读入了count, 也就是说, 线程A的三条指令本应是不可分割的,但在这三步操作间又插入了线程B的操作, 致使我们最终得到的结果有误(与可见性无关,即使使用volatile关键字也无法保证原子性)

如何保证原子性?

首先第一种方式就是加锁, Java提供的 synchronized 关键字，就是锁的一种实现 , 我们提供一把锁, 只有某一线程拿到这把锁才能对此变量进行操作, 其他线程进来后发现没有获得锁,只能在外等待, 所以synchronized锁能够很好的保持原子性 ,同样它还可以保持可见性和有序性(因为被锁住只能由一个线程进行操作)

接下来我们来看第二种可以保持原子性的方式

采用JUC( java.util.concurrent 包)原子变量

相对来说, 加锁是一种阻塞性实现, 使用原子变量是一种非阻塞实现

我们只需将普通的变量换成原子类中的原子变量即可解决原子问题

public class ThreadDemo implements Runnable {

    //private volatile int num = 0;
    private AtomicInteger num = new AtomicInteger(0);

    @Override
    public void run() {
        try {
            Thread.sleep(200);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //拿到当前线程名并且将num++
        System.out.println(Thread.currentThread().getName() + ":::" + getNum());
    }
    public int getNum() {
        //return num++;
        return num.getAndIncrement();
    }
}

public class Test {
    public static void main(String[] args) {
        ThreadDemo td = new ThreadDemo();

        for (int i = 0; i <10 ; i++) {//循环创建10个线程
            Thread t = new Thread(td);
            t.start();
        }
    }
}

在上面代码中, 我们开启10个线程, 采用原子类中的原子变量来保证我们程序中的原子性, 如果使用普通的变量 ,即使加了volatile关键字也无法保持原子性 , 那么原子类没有加锁, 是怎样保持原子性的呢?

原子类的原子性是通过 volatile + CAS 实现原子操作的。(volatile保证可见性,为CAS实现奠定基础) , 那么什么是 CAS机制呢 ?