详解Java关键字之 volatile

一、什么是Volatile

volatile是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。

Volatile 可以保证可见性，但不能保证原子性，一种线程同步的机制！很强大来看一道经典面试题~

请你谈谈你对 volatile 的理解

Volatile 是Java虚拟机提供的 轻量级的同步机制

1. 保证可见性
2. 不保证原子性
3. 禁止指令重排

二、JUC并发编程

:cloud:什么是JUC并发编程？

JUC，即​ ​java.util.concurrent​ ​包的缩写，是java原生的并发包和一些常用的工具类。

常用工具包

• java.util： 包含集合框架，旧集合类，事件模型，日期和时间设施，国际化和其他实用程序类（字符串tokenizer，随机数生成器和位数组）。
• java.util.concurrent： 实用程序类通常在并发编程中很有用。
• java.util.concurrent.atomic ： 一个小型工具包，支持单个变量上的无锁线程安全编程。
• java.util.concurrent.locks： 接口和类提供了一个框架，用于锁定和等待与内置同步和监视器不同的条件。
• java.util.function ： 功能界面提供了lambda表达式和方法引用的目标类型。

并行与并发

并行：并行是 指两个或者多个事件在同一时刻发生 ；而并发是指两个或多个事件在同一时间间隔发生。

并发： 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行 ，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行。

**​ ​并发可以充分利用CPU，从而发挥极致性能 ！​ ​**

:zap:线程的基础知识

Java真的能开线程吗

**不能，底层是调用了​ ​navtive​ ​本地方法**

进程和线程

进程：一个程序，可独立运行在计算机上

线程：基于进程运行，一个进程包含多个线程

线程的状态

源码：

public enum State {
    // 新建
    NEW,

    // 运行
    RUNNABLE,

    // 阻塞
    BLOCKED,

    // 等待
    WAITING,

    // 延时等待
    TIMED_WAITING,

    // 终止！
    TERMINATED;
}

新建 --> 运行 --> 阻塞 --> 等待 --> 超时等待 --> 终止

wait 和sleep的区别

wait 和 sleep都需要捕获异常

1. 来自不同的类

wait ---> Object sleep --> Thread

1. 关于锁的释放

wait 会释放锁，sleep休眠了，抱着锁睡觉，不会释放

1. 使用的范围不同

wait必须在同步代码块中 sleep可以在任何地方休眠

三、并发编程下 可见性问题

多线程访问共享变量，造成线程不安全，最后的数值不对

package com.wanshi.cvolatile;

public class VDemo {

    private static int num = 0;

    public static void add() {
        num++;
    }

    public static void main(String[] args) {
        //理论上应该为20000
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("执行结果："+num);
    }
}

执行结果

为什么出现这种问题？

是由于 多个线程访问同一个变量，第一个值为0，加了1，第二个又迅速的访问，发现读取到的值依旧是0 ， 没有获取到最新值，导致读取到的永远是旧值 ，这就造成了 这种问题，正常的数字应该是20000，然而少了很多。

要想解决这种问题，那就要 先了解Java内存模型了。（简称JMM）

四、JMM 内存模型

:loop:什么是JMM？

JMM（Java Memory Model）：Java 内存模型，是 Java 虚拟机规范中所定义的一种内存模型，Java 内存模型是标准化的，屏蔽掉了底层不同计算机的区别。也就是说，JMM 是 JVM 中定义的一种并发编程的底层模型机制。

JMM的约定

1. 线程解锁前，必须把共享变量 立刻 刷回主存
2. 线程加锁前，必须读取主存中的最新值到工作内存中
3. 加锁和解锁是同一把锁

:warning:多线程情况下会出现什么问题？

线程 工作内存 主存

多线程情况下修改主存的值存在的问题：

线程B修改了值，线程A不能及时可见

**关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下​ ​八种操作​ ​来完成：**

• lock（锁定） ：作用于主内存的变量，把一个变量标识为一条线程独占状态。
• unlock（解锁） ：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定。
• read（读取） ：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存中，以便随后的load动作使用
• load（载入） ：作用于工作内存的变量，它把read操作从主内存中得到的变量值放入工作内存的变量副本中。
• use（使用） ：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
• assign（赋值） ：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
• store（存储） ：作用于工作内存的变量，把工作内存中的一个变量的值传送到主内存中，以便随后的write的操作。
• write（写入） ：作用于主内存的变量，它把store操作从工作内存中一个变量的值传送到主内存的变量中。

Java内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：

• 如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
• 不允许read和load、store和write操作之一单独出现
• 不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须同步到主内存中。
• 不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回主内存中。
• 一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
• 一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
• 如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值
• 如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
• 对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和write操作）。

**由于未加任何保证可见性的操作，所以多线程下改变主存的值会造成不及时行，导致后面的线程拿的永远是第一个值，这样就​ ​会造成指令重排！​ ​**

五、并发编程 Volatile 防止指令重排

保证程序的可见性

package com.wanshi.cvolatile;

import java.util.concurrent.TimeUnit;

public class JMMDemo {

    // 不加 volatile 程序可能会死循环
    // 加上 volatile 可以保证可见性
    private volatile static int num = 0;

    public static void main(String[] args) throws InterruptedException {

        new Thread(() -> {
            while (num == 0) {

            }
        }).start();

        TimeUnit.SECONDS.sleep(1);
        num = 1;
        System.out.println(num);
    }
}

运行结果为 1

不保证原子性

原子性：不可分割 线程A执行的任务的时候，不能被打扰的，也不能被分割，要么同时成功，要么同时失败

package com.wanshi.cvolatile;

public class VDemo {

    private volatile static int num = 0;

    public static void add() {
        num++;
    }

    public static void main(String[] args) {
        //理论上应该为20000
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("执行结果："+num);
    }
}

加上 synchronized 和 Lock来保证原子性

synchronized 保证原子性

package com.wanshi.cvolatile;

public class VDemo {

    private volatile static int num = 0;

    public static void add() {
        num++;
    }

    public static void main(String[] args) {
        //理论上应该为20000
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                //加锁来保证原子性，锁的是当前线程.class
                synchronized (Thread.class) {
                    for (int j = 1; j <= 1000; j++) {
                        add();
                    }
                }
            }).start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("执行结果："+num);
    }
}

Lock保证原子性

package com.wanshi.cvolatile;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class VDemo {

    private volatile static int num = 0;

    public static void add() {
        num++;
    }

    // Lock 锁，默认为非公平锁
    private static Lock lock = new ReentrantLock();

    public static void main(String[] args) {
        //理论上应该为20000
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                try {
                    //上锁，注意，再此必须try/catch 防止程序出现异常，从而造成死锁问题
                    lock.lock();
                    for (int j = 1; j <= 1000; j++) {
                        add();
                    }
                } catch (Exception e) {

                } finally {
                    // 解锁
                    lock.unlock();
                }
            }).start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("执行结果："+num);
    }
}

执行结果均为：20000

不加 synchronized 或者 Lock怎么保证原子性

采用 原子类的方式来保证原子性

package com.wanshi.cvolatile;

import java.util.concurrent.atomic.AtomicInteger;

public class VDemo {

    //原子类的 AtumicInteger
    private volatile static AtomicInteger num = new AtomicInteger();

    public static void add() {
        //+1 方法 底层使用CAS
        num.getAndIncrement(); 
    }

    public static void main(String[] args) {
        //理论上应该为20000
        for (int i = 1; i <= 20; i++) {
            new Thread(() -> {
                for (int j = 1; j <= 1000; j++) {
                    add();
                }
            }).start();
        }

        while (Thread.activeCount() > 2) {
            Thread.yield();
        }
        System.out.println("执行结果："+num);
    }
}

运行结果为：20000

底层使用了CAS

底层和操作系统挂钩，在内存中修改值 Unsafe 是很特殊的一个类

指令重排

什么是指令重排： 你写的程序计算机并不是按照你写的那样去执行的

源代码 --> 编译器优化重排 ---> 指令并行也可能会重排 --> 内存系统也可能会重排 ---> 执行

处理器在执行指令重排的时候，考虑：数据之间的依赖性

int a = 1;  // 1 
int b = 2;  // 2
a = a + 2;  // 3
b = a * a;  // 4

//执行顺序：1234，通过指令重排后，可能是 2134, 1324

在多线程的情况下指令重排可能会导致结果不一致volatile可以避免指令重排

内存屏障，CPU指令 ，作用

1. 保证特定的操作的执行顺序
2. 可以保证某些变量的内存可见性（利用这些特性volatile实现了可见性）

volatile 读 / 写插入内存屏障规则：

• 在每个 volatile 读操作的后面插入 LoadLoad 屏障和 LoadStore 屏障。
• 在每个 volatile 写操作的前后分别插入一个 StoreStore 屏障和 一个 StoreLoad 屏障

编辑器不会对带有修饰volatile的属性产生指令重排Volatile 是可以保证可见性 不能保证原子性，由于内存屏障，可以避免指令重排的现象产生！

小结

以上就是对 【JUC并发编程 】 详解Java关键字之 volatile 简单的概述， volatile 关键字可保证程序的可见 性，但 不能保证原子性 ，volatile 关键字可以 防止JMM指令重排 ，从而 保证安全性 ，volatile是重点！