JUC探险-3、volatile_juc-3模型机结构-优快云博客

文章目录

一、：内存模型
二、：并发编程三大性质
三、：volatile关键字
系列文章传送门：

一、：内存模型

大家都知道，计算机在执行程序时，每条指令都是在CPU中执行的，而执行指令过程中，势必涉及到数据的读取和写入。由于程序运行过程中的临时数据是存放在主存（物理内存）当中的，这时就存在一个问题，由于CPU执行速度很快，而从内存读取数据和向内存写入数据的过程跟CPU执行指令的速度比起来要慢的多，因此如果任何时候对数据的操作都要通过和内存的交互来进行，会大大降低指令执行的速度。因此在CPU里面就有了高速缓存。
也就是，在程序运行的过程中，会将运算需要的数据从主存复制一份到CPU的高速缓存当中，那么CPU进行计算时就可以直接从它的高速缓存读取数据和向其中写入数据，当运算结束之后，再将高速缓存中的数据刷新到主存当中。举个简单的数值增加例子：

i = i + 1;

当线程执行这个语句时，会先从主存当中读取i的值，然后复制一份到高速缓存当中，然后CPU执行指令对i进行加1操作，然后将数据写入高速缓存，最后将高速缓存中i最新的值刷新到主存当中。

这个代码在单线程中运行是没有任何问题的，但是在多线程中运行就会有问题了。在多核CPU中，每条线程可能运行于不同的CPU中，因此每个线程运行时有自己的高速缓存（对单核CPU来说，其实也会出现这种问题，只不过是以线程调度的形式来分别执行的）。这里我们以多核CPU为例。
比如同时有2个线程执行这段代码，假如初始时i的值为0，那么我们希望两个线程执行完之后i的值变为2。但是事实会是这样吗？
可能存在下面一种情况：初始时，两个线程分别读取i的值存入各自所在的CPU的高速缓存当中，然后线程1进行加1操作，然后把i的最新值1写入到内存。此时线程2的高速缓存当中i的值还是0，进行加1操作之后，i的值为1，然后线程2把i的值写入内存。
最终结果i的值是1，而不是2。这就是著名的缓存一致性问题。通常称这种被多个线程访问的变量为共享变量。
也就是说，如果一个变量在多个CPU中都存在缓存（一般在多线程编程时才会出现），那么就可能存在缓存不一致的问题。

为了解决缓存不一致性问题，通常来说有以下2种解决方法：
●通过在总线加LOCK锁的方式。
●通过缓存一致性协议。
这2种方式都是硬件层面上提供的方式。

在早期的CPU当中，是通过在总线上加LOCK锁的形式来解决缓存不一致的问题。因为CPU和其他部件进行通信都是通过总线来进行的，如果对总线加LOCK锁的话，也就是说阻塞了其他CPU对其他部件访问（如内存），从而使得只能有一个CPU能使用这个变量的内存。比如上面例子中如果一个线程在执行 i = i +1，如果在执行这段代码的过程中，在总线上发出了LCOK锁的信号，那么只有等待这段代码完全执行完毕之后，其他CPU才能从变量i所在的内存读取变量，然后进行相应的操作。这样就解决了缓存不一致的问题。
但是这样的方式会有一个问题：在锁住总线期间，其他CPU无法访问内存，因此导致效率低下。
所以就出现了缓存一致性协议。最出名的就是Intel的MESI协议，MESI协议保证了每个缓存中使用的共享变量的副本是一致的。它核心的思想是：当CPU写数据时，如果发现操作的变量是共享变量，即在其他CPU中也存在该变量的副本，会发出信号通知其他CPU将该变量的缓存行置为无效状态，因此当其他CPU需要读取这个变量时，发现自己缓存中缓存该变量的缓存行是无效的，那么它就会从内存重新读取。

二、：并发编程三大性质

在并发编程中，我们通常会遇到以下三个问题：原子性问题，可见性问题，有序性问题。

①原子性

原子性是指一个操作是不可中断的，要么全部执行成功要么全部执行失败。

下面举几个例子，方便更直观的理解：

int a = 10;
a++;
int b = a;
a = a + 1;

上面这四条语句中只有第1条语句是原子操作，将10赋值给变量a。
第2条语句（a++），实际上包含了三个操作：1、读取变量a的值；2、对a进行加一的操作；3、将计算后的值再赋值给变量a，而这三个操作无法构成原子操作。
对语句3、4的分析同理可得这两条语句不具备原子性。

java内存模型中定义了8种原子操作：

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

②可见性

可见性是指当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。

导致不可见的原因：
●线程交叉执行。
●指令重排序+线程交叉执行。
●工作内存与主内存间数据未及时同步。

synchronized保证可见性：
●线程解锁前，必须把共享变量的最新值刷新到主内存。
●线程加锁时，将清空工作内存中共享变量的值，此时，使用共享变量时需要从主内存中重新读取最新的值。（注意，加锁与解锁是同一把锁，如果不是同一把锁，那么彼此之间互不影响）

volatile保证可见性：
●对 volatile 变量写操作时，会在写操作后加入一条 store 屏障指令，将本地内存中的共享变量值刷新到主内存。
●对 volatile 变量读操作时，会在读操作前加入一条 load 屏障指令，从主内存中读取变量。
●简单来讲，volatile 变量读操作时，会强制从主内存读取变量；对其写操作时，会强制写回主内存。

③有序性

有序性是指程序执行的顺序按照代码的先后顺序执行。

在 Java 内存模型中，为了性能优化，允许编译器和处理器对指令进行重排序。重排序过程不会影响到单线程程序的执行，却会影响到多线程并发执行的正确性。

另外，Java内存模型具备一些先天的“有序性”，即不需要通过任何手段就能够得到保证的有序性，这个通常也称为 happens-before 原则。如果两个操作的执行次序无法从happens-before原则推导出来，那么就不能保证它们的有序性，虚拟机可以随意地对它们进行重排序。
下面就来具体介绍下happens-before原则（先行发生原则）：
●程序次序规则（Program Order Rule）：在一个线程内，按照程序代码顺序，书写在前面的操作Happens-Before书写在后面的操作。
●管程锁定规则（Monitor Lock Rule）：An unlock on a monitor happens-before every subsequent lock on that monitor. 一个unlock操作Happens-Before后面对同一个锁的lock操作。
●volatile变量规则（volatile Variable Rule）：A write to a volatile field happens-before every subsequent read of that volatile. 对一个volatile变量的写入操作Happens-Before后面对这个变量的读操作。
●传递性（Transitivity）：偏序关系的传递性：如果已知hb(a,b)和hb(b,c)，那么我们可以推导出hb(a,c)，即操作a Happens-Before 操作c。
●线程启动规则（Thread Start Rule）：Thread对象的start()方法Happens-Before此线程的每一个动作。
●线程终止规则（Thread Termination Rule）：线程中的所有操作都Happens-Before对此线程的终止检测。
●线程中断规则（Thread Interruption Rule）：对线程interrupt()方法的调用Happens-Before被中断线程的代码检测到中断事件的发生，可以通过Thread.interrupt()方法检测到是否有中断发生。
●对象终结规则（Finalizer Rule）：一个对象的初始化完成（构造函数执行结束）Happens-Before它的finalize()方法的开始。

这8条规则中，前4条规则是比较重要的，后4条规则都是显而易见的。
下面我们来分析一下前4条规则：
●程序次序规则，可以解释为：一段程序代码的执行在单个线程中看起来是有序的。这个规则是用来保证程序在单线程中执行结果的正确性，但无法保证程序在多线程中执行的正确性。
●管程锁定规则，可以解释为：无论在单线程中还是多线程中，同一个锁如果出于被锁定的状态，那么必须先对锁进行了释放操作，后面才能继续进行lock操作。
●volatile变量规则，可以解释为：如果一个线程先去写一个变量，然后一个线程去进行读取，那么写入操作肯定会先行发生于读操作。
●传递性，其实就是说：happens-before原则具备传递性。

三、：volatile关键字

①volatile关键字语义

一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
●保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的。
●保证了有序性，禁止进行指令重排序。

②volatile与原子性

一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，仍然无法保证原子性。

对于原子性，在java 1.5的java.util.concurrent.atomic包下提供了一些原子操作类，即对基本数据类型的自增（加1操作）、自减（减1操作）、以及加法操作（加一个数），减法操作（减一个数）等进行了封装，保证这些操作是原子性操作。atomic是利用CAS来实现原子性操作的（Compare And Swap），CAS实际上是利用处理器提供的CMPXCHG指令实现的，而处理器执行CMPXCHG指令是一个原子性操作。

③volatile与有序性

volatile关键字禁止指令重排序有两层意思：
●当程序执行到volatile变量的读操作或者写操作时，在其前面的操作的更改肯定全部已经进行，且结果已经对后面的操作可见；在其后面的操作肯定还没有进行。
●在进行指令优化时，不能将在对volatile变量访问的语句放在其后面执行，也不能把volatile变量后面的语句放到其前面执行。

④volatile的原理和实现机制

观察加入volatile关键字和没有加入volatile关键字时所生成的汇编代码发现，加入volatile关键字时，会多出一个lock前缀指令。lock前缀指令实际上相当于一个内存屏障（也成内存栅栏），内存屏障会提供3个功能：
●它确保指令重排序时不会把其后面的指令排到内存屏障之前的位置，也不会把前面的指令排到内存屏障的后面。即在执行到内存屏障这句指令时，在它前面的操作已经全部完成。
●它会强制将对缓存的修改操作立即写入主存。
●如果是写操作，它会导致其他CPU中对应的缓存行无效。

⑤volatile的适用场景

总结可知，volatile关键字保证了可见性与有序性，并不能保证原子性。因此，要使volatile变量提供理想的线程安全，必须同时满足下面两个条件：
●对变量的写操作不依赖于当前值。
●该变量没有包含在具有其他变量的不变式中。

1、状态标志

这种类型的状态标记的一个公共特性是：通常只有一种状态转换。这种模式可以扩展到来回转换的状态标志，但是只有在转换周期不被察觉的情况下才能扩展（从false 到true，再转换到false）。此外，还需要某些原子状态转换机制，例如原子变量。
比如根据某个状态决定是否做某件事：

volatile boolean flag = false;

while(!flag){
    doSomething();
}

public void setFlag() {
    flag = true;
}

2、一次性安全发布（one-time safe publication）

在缺乏同步的情况下，可能会遇到某个对象引用的更新值（由另一个线程写入）和该对象状态的旧值同时存在。比如双重检查锁定（double-checked-locking）：

class Singleton{
    private volatile static Singleton instance = null;

    public static Singleton getInstance() {
        if(instance == null) {
            synchronized (Singleton.class) {
                if(instance == null)
                    instance = new Singleton();
            }
        }
        return instance;
    }
}

此时如果instance不使用volatile修饰的话，可能发生以下情况：
●线程A进入getInstance()方法。由于此时instance为null，线程A进入synchronized块。
●线程A执行到构造函数，使instance变为非空，但尚未初始化完毕，此时切换到线程B。
●线程B检查instance非空，返回部分初始化的instance。
●切换到线程A，继续完成instance的初始化，最终返回。
最终可能导致某些线程获得一个未完全初始化的实例。

3、独立观察（independent observation）

可以简单的用于一些非累加值的记录。比如记录最近一次登陆的用户：

public class UserManager {
    public volatile String lastUser;
 
    public boolean authenticate(String userName, String password) {
        boolean valid = checkPassword(userName, password);
        if (valid) {
            User u = new User(userName);
            activeUsers.add(u);
            lastUser = userName;
        }
        return valid;
    }
}

4、“volatile bean” 模式

volatile bean模式的基本需求是：很多框架为易变数据的持有者（例如HttpSession）提供了容器，但是放入这些容器中的对象必须是线程安全的。
在volatile bean模式中，JavaBean的所有数据成员都是volatile修饰的，并且getter和setter方法必须非常普通（即不包含约束）。比如：

@ThreadSafe
public class Person {
    private volatile String name;
    private volatile int age;
 
    public String getName() { return name; }
    public int getAge() { return age; }
 
    public void setName(String firstName) { 
        this.name = name;
    }
    public void setAge(int age) { 
        this.age = age;
    }
}

5、开销较低的“读－写锁”策略

如果读操作远远超过写操作，可以结合使用内部锁和volatile变量来减少公共代码路径的开销。锁一次只允许一个线程访问值，volatile 允许多个线程执行读操作，从而提高性能。比如一个简单的计数器：

@ThreadSafe
public class counter {
    private volatile int value;

    // 读操作，没有synchronized，提高性能
    public int getValue() {
        return value;
    }

    // 写操作，必须synchronized。因为volatile不保证原子性
    public synchronized int increment() {
        return value++;
    }
}