目录

可见性问题

有序性问题

volatile 关键字

原子性问题

i ++是安全的吗?

如何保证原子性?

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机制呢 ?

CAS(Compare-And-Swap)

          翻译过来就是 : 比较并交换, 先来看下面这样一段话

CAS 是乐观锁的一种实现方式，他采用的是自旋锁的思想，是一种轻量级的锁机制。

        一上来直接三个锁, 之前没了解过的同学可能有点懵, 首先我们粗略解释一下这几个名词, 后面再java中都有哪些锁再来详细解释这些锁 : 乐观锁 : 就是不加锁, 乐观的认为不显式的加锁是没有事情的 , 自旋锁: 不断循环重试 , 轻量级锁 : 不阻塞式的尝试获得锁

        那么CAS具体是怎样去做的呢 ?

首先CAS包括三个操作数 : ①内存值 V  ②预估值 A (比较时,从内存中再次读到的值)  ③更新值 B (更新后的值), 当且仅当预期值 A==V，将内存值 V=B，否则什么都不做。

          即每次判断我的预期值和内存中的值是不是相同，如果不相同则说明该内存值已经被其他线程更新过了，因此需要拿到该最新值作为预期值，重新判断。而该线程不断的循环判断是否该内存值已经被其他线程更新过了，这就是自旋的思想。

         先将 V 读入操作 , 这时操作完后值为 B , 此时不急着将B更新回去, 而是从内存中再读入一遍得到A,  如果此时A==V , 才将V = B, 如果A==V, 那么接着自旋

        这种做法的效率高于加锁, 因为不会阻塞, 可以获得CPU的执行权, 我们先来看一下刚使用的getAndIncrement() 方法(此方法类似于num++操作,但保证原子性)底层

 可以看到 , getAndIncrement()方法底层的 getAndAddInt()方法中包含三个操作数, 这就是采用了CAS机制的做法, 另外为了保证可见性, 底层的value也是加了volatile关键字, 如下

      CAS的做法虽然好, 但也有缺点, 在高并发的情况下, 只能一直自旋(还没来及写值, 其他线程抢先操作,它只能继续自旋判断) , 无法去操作共享变量, 在高并发的情况下极大的消耗了CPU , 所以我们一般推荐在低并发下使用CAS, 同样原子类采用了CAS机制 , 那么它也是在低并发情况下执行

      另外CAS的做法还会产生ABA问题

ABA问题

       试想, 有一共享变量为A , 此时另一个线程将A改成了B , 然后又改回A了 , 这时候我们再拿预期值的时候, 就会认为此变量并没有被操作过 , 这就是ABA问题

       那么如何来解决呢 ? 

     我们可以通过类似添加版本号的方式, 来避免ABA问题 , 刚开始值可以标记为(A,1), 修改后为(B,2), 再次修改回来后为(A,3) , 此时就可以区分这两个变量间的差异(比较版本号),解决ABA问题