synchronized 与 volatile 原理 —— 内存屏障的重要实践

单例模式的双重校验锁的实现：

第一种：

private static Singleton _instance;

public static synchronized Singleton getInstance() {
    if (_instance == null) {
        _instance = new Singleton();
    }
    return _instance;
}

　　

在 static 方法上加 synchronized，等同于将整个类锁住。每当通过此静态方法得到该对象时，就需要同步。

如果是实例方法（不是 static），那个 synchronized 锁只会对同一个对象多次调用该方法才会同步，不同的对象（实例）调用则不保证同步性。

if (_instance == null) {
        _instance = new Singleton();
}

　　

第二种：

public class Singleton {

    //volatile 防止延迟初始化
    private volatile static Singleton instance;

    public static Singleton getInstance() {
        if (instance == null) { //判断是否已有单例生成
            synchronized (Singleton.class) { //获取单例的方法是static方法，所以锁的是 .class对象
                if (instance == null)  //判断 是否在第一重判断与 synchronized 语句之间的状态，已经被另一个 synchronized 块 赋值
                    instance = new Singleton();//instance为volatile，现在没问题了
            }
        }
        return instance;
    }
}

　　

判断是否有单例生成并不需要同步锁，只有在第一次单例类实例创建时需要同步锁。并且在同步锁中赋值时，还需再检验一次。

这里使用 volatile 的目的是：避免重排序。直接原因也就是 instance = new Singleton();  初始化（初始化本身是原子操作）一个对象并使另一个引用指向他 这个过程可分为多个步骤：

• 1. 分配内存空间，
• 2. 初始化默认值（区别于构造器方法的初始化），
• 3. 初始化对象，
• 4. 将引用与对应的变量绑定。

如果最后 2步替换顺序，1243 执行。则导致了可能会出现（怎样出现？）引用指向了对象并未初始化好的那块堆内存。

注意：这里的 synchronized 不像第一种是直接在整个方法上添加的，而是在内部的代码块上添加的，也就是说该方法的第一重判断是不包括在 synchronized 里面的，并且返回语句也不在 synchronized 中。当线程一按照1243 的执行顺序，首次访问到 步骤 4时。线程二异步执行到第一重判断时，它判断不为空，获取到了一个未初始化好的内存。线程一继续往下执行，它获取到了一个真实的初始化的对象。

概念：Jvm 中的 重排序、主存、原子操作

拓展：

线程安全：多条线程同时工作的情况下,通过运用线程锁,原子操作等方法避免多条线程因为同时访问同一快内存造成的数据错误或冲突。

原子性：解决的是某一操作不会被线程调度机制打断，中间不会有任何context switch （切 换到另一个线程）。即保证当前为原子操作。

有序性：解决的是 cpu 进行指令重排序

可见性：解决的是工作内存/寄存器 对主存的不可见

内存屏障：为了解决写缓冲器和无效化队列带来的有序性和可见性问题，我们引入了内存屏障。内存屏障是被插入两个CPU指令之间的一种指令，用来禁止处理器指令发生重排序（像屏障一样），从而保障有序性的。另外，为了达到屏障的效果，它也会使处理器写入、读取值之前，将写缓冲器的值写入高速缓存，清空无效队列，从而“附带”的保障了可见性。

八 种原子操作：

lock(锁定)：作用于主内存中的变量，它把一个变量标识为一个线程独占的状态；

unlock(解锁):作用于主内存中的变量，它把一个处于锁定状态的变量释放出来，释放后的变量才可以被其他线程锁定

read（读取）：作用于主内存的变量，它把一个变量的值从主内存传输到线程的工作内存中，以便后面的load动作使用；

load（载入）：作用于工作内存中的变量，它把read操作从主内存中得到的变量值放入工作内存中的变量副本

use（使用）：作用于工作内存中的变量，它把工作内存中一个变量的值传递给执行引擎，每当虚拟机遇到一个需要使用到变量的值的字节码指令时将会执行这个操作；

assign（赋值）：作用于工作内存中的变量，它把一个从执行引擎接收到的值赋给工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作；

store（存储）：作用于工作内存的变量，它把工作内存中一个变量的值传送给主内存中以便随后的write操作使用；

write（操作）：作用于主内存的变量，它把store操作从工作内存中得到的变量的值放入主内存的变量中。

四种基本内存屏障：

LoadLoad屏障：
对于这样的语句 Load1; LoadLoad; Load2，在Load2及后续读取操作要读取的数据被访问前，保证Load1要读取的数据被读取完毕。
StoreStore屏障：
对于这样的语句 Store1; StoreStore; Store2，在Store2及后续写入操作执行前，保证Store1的写入操作对其它处理器可见。
LoadStore屏障：
对于这样的语句Load1; LoadStore; Store2，在Store2及后续写入操作被执行前，保证Load1要读取的数据被读取完毕。
StoreLoad屏障：
对于这样的语句Store1; StoreLoad; Load2，在Load2及后续所有读取操作执行前，保证Store1的写入对所有处理器可见。它的开销是四种屏障中最大的（冲刷写缓冲器，清空无效化队列）。在大多数处理器的实现中，这个屏障是个万能屏障，兼具其它三种内存屏障的功能。

内存屏障分类

• 按照可见性保障来划分
  内存屏障可分为：加载屏障（Load Barrier）和存储屏障（Store Barrier）。
  加载屏障：StoreLoad屏障可充当加载屏障，作用是使用load 原子操作，刷新处理器缓存，即清空无效化队列，使处理器在读取共享变量时，先从主内存或其他处理器的高速缓存中读取相应变量，更新到自己的缓存中
  存储屏障：StoreLoad屏障可充当存储屏障，作用是使用 store 原子操作，冲刷处理器缓存，即将写缓冲器内容写入高速缓存中，使处理器对共享变量的更新写入高速缓存或者主内存中
  这两个屏障一起保证了数据在多处理器之间是可见的。

• 按照有序性保障来划分
  内存屏障分为：获取屏障（Acquire Barrier）和释放屏障（Release Barrier）。
  获取屏障：相当于LoadLoad屏障与LoadStore屏障的组合。在读操作后插入，禁止该读操作与其后的任何读写操作发生重排序；
  释放屏障：相当于LoadStore屏障与StoreStore屏障的组合。在一个写操作之前插入，禁止该写操作与其前面的任何读写操作发生重排序。
  这两个屏障一起保证了临界区中的任何读写操作不可能被重排序到临界区之外。

 

 

1. Synchronized 底层原理（保证有序性，可见性，原子性与线程安全）

synchronized编译成字节码后，是通过monitorenter（lock原子操作抽象而来）和 monitorexit（unlock原子操作抽象而来）两个指令实现的，具体过程如下：

可以发现，synchronized底层通过获取屏障和释放屏障的配对使用保证有序性，加载屏障和存储屏障的配对使用保正可见性。最后又通过锁的排他性保障了原子性与线程安全。

2. Volatile 底层原理（保证有序性，可见性）

与 synchronized 类似，volatile 也是通过内存屏障来保证有序性与可见性，过程如下：

读操作：

写操作：

经过对比，可以发现 volatile 少了两个指令 monitorenter 与 monitorexit 用来保证原子性与线程安全。

 

 

注意：

一、原子性与线程安全的理解

1> 对于基本数据类型的“简单操作”，除了 long 与 double 外都具有原子性。因为 long 与 double 的读取和写入被 Jvm 分离成 2个slot 操作来进行，可以使用 volatile 来保证简单的赋值与返回操作的原子性。这是 volatile 的特殊用法，其基本用法是保证可见性和有序性。

2> 原子类扩展了“简单操作”的范围，增加对额外一些操作的原子性。

3> 原子操作并不能确保线程安全，虽然保证部分操作的原子性，但是对于大部分情况下仍然需要同步控制。

 

二、数组与对象实例中的 volatile

针对的是引用，其含义是对象获数组的地址具有可见性，但是数组或对象内部的成员改变不具备可见性。这一点跟变量中 final 数组/对象 的用法是类似的，限定是引用地址。

关于 synchronized 的知识点

下列说法不正确的是（）
A.当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。
B.当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。
C.当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问不会被阻塞。
D.当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。
答案：C，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将会被阻塞。

参考资料

---

https://blog.csdn.net/guyuealian/article/details/52525724

https://www.jianshu.com/p/43af2cc32f90