多线程总结-底层原理

本文从CPU指令的乱序执行，synchronized, volatile的语义原理及操作系统层面对多线程的支持进行相关知识点的总结。

乱序执行

编译层面指令重排

在编译期，编译器在不改变单线程程序语义的前提下，可以重新安排语句的执行顺序。如

a = 1;
b = 2;

这两行的代码没有任何的依赖关系，在编译时，编译器可能会将其进行重排。

CPU的指令重排

处理器为了提高程序运行效率，可能会对输入代码进行优化，它不保证程序中各个语句的执行先后顺序同代码中的顺序一致，但是它会保证程序最终执行结果和代码顺序执行的结果是一致的。指令重排序不会影响单个线程的执行，但是会影响到线程并发执行的正确性

解决乱序执行的方案

CPU层面: intel 采用原语(mfence, lfence, sfence) 或者锁总线
JVM层: 采用内存屏障，内存屏障就是对某部份内存做操作时前后添加屏障，屏障前后的操作不可以乱序执行。

volatile

volatile语义

当一个线程修改了一个被volatile修饰的共享变量的值时，新值总是可以被其它的线程立即知道

对于volatile修饰的变量，CPU会将其对应的缓存行数据马上写回系统内存，同时写回内存的操作使其它CPU缓存该内存地址的数据无效。在读一个volatile变量时，JMM会将该线程对应的本地内存置为无效，线程会从主内存中读取数据。
禁止指令重排

volatile在JVM中实现: volatile修饰的变量在写作操前加入StoreStoreBarrier, 写操作后加上StoreLoadBarrier, 在读操作前加上LoadLoadBarrier, 读操作后加上LoadStoreBarrier。

用volatile实现单例

关于java中单例模式有多种实现方式，其中有一种是DCL(Double Check Lock双重检查锁定)模式, 会涉及到volatile关键词的使用，这里简单列一下

public class Singleton {
    private volatile static Singleton instance;
    
    private Singleton() {}

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

此处之所以要用volatile来修饰是因为instance = new Singleton();这一步，其实对于应有三个步骤，分别是

1. 分配内存空间
2. 初始化对象
3. 将内存空间的地址赋给对应的引用

CPU在运行，有可能会发生指令重排，第3步可能在第2步之前运行。假设有两个线程，如果线程A执行到代码instance = new Singleton();, 如果第3步在第2步之前运行，也就是虽然开辟了内存空间，instance引用也有了值。但其实对应的对象还没有初始化好，此时如果再调用该对象的某些属性会方法会报错。如果此时线程B进来了，在执行if (instance == null)语句时，因为instance不为空，故不会执行下面的代码，直接拿当前的instance，同样拿到的instance也是尚未初始化完成的。

单例模式的实现有多种方式，后面会开一篇文章总结一下

final域内存语义

java中用final来表示属性的不可变。final域的重排序规则如下：

写操作

在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用变量，这两个操作之间不能重排序。编译器会在final域的写之后，构造函数的返回之前，插入一个StoreStore屏障。这个屏障禁止处理器把final域的写重排序到构造函数之外

读操作

在一个线程中，初次读对象引用与初次读该对象包含的final域，JMM会禁止重排序这两个操作。编译器会在读final域操作的前面插入一个LoadLoad屏障。初次读对象引用与初次读该对象包含的final域这两个操作之间存在间接依赖的关系，因些编译器不会重排序这两个操作，大多数处理器也会遵间接依赖，不会去重排序。但有少数处理器会有这个操作，这个规则便是针对少数处理器的。

在《Java并发编程的艺术》一书中有这个例子，假设一个线程A执行writer()方法，另一个线程B执行reader()方法。

public class FinalExample {
    int i ;
    final int j;
    static FinalExample obj;

    public FinalExample() {
        i = 1;
        j = 2;
    }

    public static void writer() {
        obj = new FinalExample();
    }

    public static void reader() {
        FinalExample object = obj;
        int a = object.i;
        int b = object.j;
    }
}

在前面有介绍，对于语句obj = new FinalExample();其实对应有三个步骤：

分配内存空间
初始化对象
将内存空间的地址赋给对应的引用

CPU在执行时的指令重排，可能会导致第2个步骤在第3个步骤之后执行。对于以上代码就是返回的obj是一个还没有初始化好的对象。虽然构造函数执行了，但是其属性还未初始化完成，所以此时如果有一个线程B来调用其reader方法，拿到的属性便是错误的数据。而final关键字会禁止CPU的这一行为，保证其初始化在构造函数返回之前执行。

synchronized

synchronized关键字可以作用于普通方法，静态方法，代码块，运行时会对相应的位子进行加锁。

对于普通方法，锁是当前实例, 所以只有同一个实例调用该方法才会互斥
对于静态方法，锁是当前类的Class对象，类级别的锁。即使在不同的线程中调用不同实例对象，也会有互斥效果
对于同步代码块，锁是sychronized括号里配置的对象

普通方法/静态方法

我们定义一个类如下:

package com.fred.javalib.thread;

public class EmptyClass {
    public synchronized void syncMethod() {
    }

    public synchronized static void syncStaticMethod() {
    }
}

查看其字节码文件

可以发现, 被sychronized修饰的方法在被编译后，其方法的flags属性中会多一个ACC_SYNCHRONIZED标识。当虚拟机在访问有这个标识的方法时，会在相应的位置添加monitorenter和monitorexit指令

同步代码块

对于同步代码块, 是靠monitorenter, monitorexit指令来实现，我们用javap -verbose Singleton.class来看一下上面用volatile关键字实现的单例模式相关代码。

可以看到在上面的字节码中，有一个monitorenter 和 2个monitorexit。有monitorenter是去拿锁, 有两个monitorexit是因为其中一个是代码正常执行结束后释放锁，一个是在代码执行异常时释放锁。

happens-before规则

保证线和可见性的机制，前面一个操作的结果对后续操作是可见的。

1. 程序的顺序性原则

在一个线程中，按照程序顺序，前面的操作happens-before于后续的任意操作。

2. volatile变量规则

对于一个volatile变量的写操作, happens-before于后续对这个volatile变量的读操作。

3. 传递性

如果A happens-before B，且 B happens-before C，那么 A happens-before C。

4. 锁的规则

对于一个锁的解锁Happens-Before于后续对这个锁的加锁。

5. 线程start()规则

它是指主线程 A 启动子线程 B 后，子线程 B 能够看到主线程在启动子线程 B 前的操作。

6. 线程join()规则

主线程A等待子线程B完成(主线程 A 通过调用子线程 B 的 join() 方法实现), 当子线程B完成后(主线程A中的join方法返回) 主线程能看到子线程的操作。所谓的“看到”，指的是对共享变量的操作。

操作系统层面提供的两种同步的方法

信号量与管程都是操作系统提供的两种同步的方法。多线程的并发导致资源竞争。同步就是协调多线程对共享数据的访问，任何时刻只能有一个线程访问。

信号量

信号量(semaphore) 是操作系统提供的协调共享资源访问的方法。软件同步是平等线程间的一种同步协商机制，信号量是由OS来进行管理的。信号量用来表示系统的一类资源，信号量的取值就是一类资源数。由Dijkstra在20世纪60年代提出, 是早期的操作系统里的主要同步机制，但现在很少用。信号量是一种抽象的数据类型:

由一个整型变量(sem)和两个原子操作组成
P()操作（荷兰语尝试减少）
sem 减 1
如sem < 0, 进入等待，否则继续
V()
sem 加 1
如sem <=0, 唤醒一个等待进程

信号量是被保护的整型变量，初始化完成后，只能通过P和V操作修改，由操作系统保证，PV操作都是原子操作

P可能阻塞，V不会阻塞（V操作只会释放资源, 不可能阻塞）
通常假定信号量是公平的，结程不会被无限期阻塞在P操作里，假定信号量等待按先进先出排队。

信号量实现临界区的资源访问

mutex = new Semaphore(1);
mutex->P();
Critical Section; //临界区资源访问
mutext->V();

运行流程如下：

每类资源设置一个信号量，其初始值为 1
第一个线程来时，信号量为1, 执行P操作，信号量减1；
进入临界区
第二个线程来，此时信号量为 0，再执行P操作，信号量减1, 此时信号量为-1，于是第二个线程进入等待对队
第一个线程进入退出区，此时信号量为-1，于是操作系统知道有一个线程还在等待。执行V操作，信号量加1，同时唤起另一个等待的线程。

在使用信号量实现临界区的互斥访问时，必须成对使用P操作和V操作。

用信号量实现条件同步

前面描述了用信号量解决临界区资源的访问问题，在此基础之上，我们看一下，如何利用信号量来实现条件同步，以下以生产者-消费者模型为例。生产者-消费者模型的主要特点如下：

在任何时刻只能有一个线程操作缓冲区（互斥访问）
缓冲区空时，消费者必须等待生产生（条件同步）
缓冲区满时，生产者必须等待消费者（条件同步）

左侧是生产者，右测是消费者。生产者产生数据并放入缓冲区，消费者将数据移出缓冲区。

生产者

检测缓冲区是否有空间
生产数据的原子操作
fullBuffers 执行V操作，已使用空间 + 1

消费者

检测fullBuffers是否有数据
移除数据的原子操作
emptyBuffers执行V操作，空余空间 + 1

信号量总结

信号量虽然可以实现临界区的互斥访问和条件同步，但其编码过程容易出错，开发在使用时必须要牢记PV配对。在生产者消费者模型里面，信号量的PV操作是分散在两个不同的线程中，在这种情况下，PV操作的配对比较困难，同时信号量是没有办法避免死锁的问题。

管程(Monitor)

管程便是为了解决信号量的痛点，在在管程里可以把PV操作都集中在一个模块, 从而降低实现难度。那么什么是管程? 管程是一种用于多线程互斥访问共享资源的程序结构。

采用面向对象的方法，简化了线程间的同步控制
任一时刻最多只有一个线程执行管程代码
正在管程中的线程可临时放弃管程的互斥访问，等待事件出现时恢复。这是与信号量的不同，信号量是要把临界区的代码完全执行完。(联想到wait方法)

管程的组成

管程由以下两个部份组成:

一个锁，用来控制管程代码互斥访问
0或者多个条件变理，管理共享数据的并发访问。

锁

联想到java语言，这里的锁对应的便是synchronized关键字，xxxLock。

条件变量

条件变量是管程内的等待机制
- 进入管程的线程因资源被占用而进入等待状态
- 每个条件变理表示一种等待原因，对应一个等待对列
Wait()操作
- 将自己阻塞在等待队列中
- 唤醒一个等待或释放管程的互斥访问
Signal()操作
- 将等待队列中的一个线程唤醒
- 如果等待队列为空，则等同于空操作

再联想到java中的多线程，synchronized关键字，各种锁，Object类中的wait, notify, notifyAll方法和管程的设计思路是一致的，所以java中解决并发的问题确实就是依赖于管程。