Java并发编程核心概念

JAVA内存模型

Java线程之间的通信由Java内存模型（本文简称为JMM）控制，JMM决定一个线程对共享 变量的写入何时对另一个线程可见。从抽象的角度来看，JMM定义了线程和主内存之间的抽 象关系：线程之间的共享变量存储在主内存（Main Memory）中，每个线程都有一个私有的本地 内存（Local Memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的 一个抽象概念，并不真实存在。它涵盖了缓存、写缓冲区、寄存器以及其他的硬件和编译器优化。

重排序

重排序是指编译器和处理器为了优化程序性能而对指令序列进行重新排序的一种手段。

现代的处理器使用写缓冲区临时保存向内存写入的数据。写缓冲区可以保证指令流水线 持续运行，它可以避免由于处理器停顿下来等待向内存写入数据而产生的延迟。同时，通过以 批处理的方式刷新写缓冲区，以及合并写缓冲区中对同一内存地址的多次写，减少对内存总 线的占用。虽然写缓冲区有这么多好处，但每个处理器上的写缓冲区，仅仅对它所在的处理器 可见。这个特性会对内存操作的执行顺序产生重要的影响：处理器对内存的读/写操作的执行 顺序，不一定与内存实际发生的读/写操作顺序一致。

指令重排序

在执行程序时，为了提高性能，编译器和处理器常常会对指令做重排序。重排序分3种类 型。

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

2）指令级并行的重排序。现代处理器采用了指令级并行技术（Instruction-Level Parallelism，ILP）来将多条指令重叠执行。如果不存在数据依赖性，处理器可以改变语句对应 机器指令的执行顺序。

3）内存系统的重排序。由于处理器使用缓存和读/写缓冲区，这使得加载和存储操作看上 去可能是在乱序执行。

源代码 -> 1.编译器优化：指令重排序 -> 2.指令级：并行重排序 -> 3.内存系统重排序 -> 最终执行的指令序列

其中：1属于编译器重排序，2和3属于处理器重排序。对于编译器，JMM的编译器重排序规则会禁止特定类型的编译器重排序（不是所有的编译器重排序都要禁止）。对于处理器重排序，JMM的处理器重排序规则会要 求Java编译器在生成指令序列时，插入特定类型的内存屏障（Memory Barriers，Intel称之为 Memory Fence）指令，通过内存屏障指令来禁止特定类型的处理器重排序。

内存屏障

内存屏障的类型如下:

屏障类型	指令示例	说明
LoadLoad	Load1；LoadLoad；Load2;	确保Load1数据的装载先于Load2及所有后续装载指令的装载
StoreStore	Store1；StoreStore；Store2;	确保Store1的数据对其他处理器可见（刷新到内存）先于Store2及所有后续存储指令的存储
LoadStore	Load1; LoadStore; Store2;	确保Load1数据装载先于Store2及所有的后续存储指令刷新到内存
StoreLoad	Store1; StoreLoad; Load2	确保Store1数据对其他处理器变得可见（之刷新到内存）先于Load2及所有后续装载指令的装载。StoreLoad Barriers会使该屏障之前的所有的内存访问指令（存储和装载指令）完成之后，才执行该屏障之后的内存访问指令。

StoreLoad Barriers是一个“全能型”的屏障，它同时具有其他3个屏障的效果。现代的多处 理器大多支持该屏障（其他类型的屏障不一定被所有处理器支持）。执行该屏障开销会很昂 贵，因为当前处理器通常要把写缓冲区中的数据全部刷新到内存中（Buffer Fully Flush）。

Happens-Before

1. 程序顺序规则：一个线程中的每个操作，happens-before于该线程中的任意后续操作。

2. 监视器锁规则：对一个锁的解锁，happens-before于随后对这个锁的加锁。

3. volatile变量规则：对一个volatile域的写，happens-before于任意后续对这个volatile域的 读。

4. 传递性：如果A happens-before B，且B happens-before C，那么A happens-before C。

5. start()规则：如果线程A执行操作ThreadB.start()（启动线程B），那么A线程的 ThreadB.start()操作happens-before于线程B中的任意操作。

6. join()规则：如果线程A执行操作ThreadB.join()并成功返回，那么线程B中的任意操作 happens-before于线程A从ThreadB.join()操作成功返回。

两个操作之间具有happens-before关系，并不意味着前一个操作必须要在后一个 操作之前执行！happens-before仅仅要求前一个操作（执行的结果）对后一个操作可见，且前一 个操作按顺序排在第二个操作之前。

AS-If-Serial

as-if-serial语义的意思是：不管怎么重排序（编译器和处理器为了提高并行度），（单线程） 程序的执行结果不能被改变。编译器、runtime和处理器都必须遵守as-if-serial语义。

为了遵守as-if-serial语义，编译器和处理器不会对存在数据依赖关系的操作做重排序，因 为这种重排序会改变执行结果。但是，如果操作之间不存在数据依赖关系，这些操作就可能被 编译器和处理器重排序。

Volatile的内存语义

volatile变量特性：

1. 可见性。对一个volatile变量的读，总是能看到（任意线程）对这个volatile变量最后的写 入。

2. 原子性：对任意单个volatile变量的读/写具有原子性，但类似于volatile++这种复合操作不 具有原子性。

volatile写的内存语义：

1. 当写一个volatile变量时，JMM会把该线程对应的本地内存中的共享变量值刷新到主内 存。

volatile内存语义的实现

重排序分为编译器重排序和处理器重排序。为了实现volatile内存语义，JMM 会分别限制这两种类型的重排序类型。

是否能重排序	第二个操作	第二个操作	第二个操作
第一个操作	普通读/写	volatile读	volatile写
普通读/写			NO
volatile读	NO	NO	NO
volatile写		NO	NO

举例来说，第三行最后一个单元格的意思是：在程序中，当第一个操作为普通变量的读或 写时，如果第二个操作为volatile写，则编译器不能重排序这两个操作。

为了实现volatile的内存语义，编译器在生成字节码时，会在指令序列中插入内存屏障来 禁止特定类型的处理器重排序：

1. 在每个volatile写操作的前面插入一个StoreStore屏障。

2. 在每个volatile写操作的后面插入一个StoreLoad屏障。

3. 在每个volatile读操作的后面插入一个LoadLoad屏障。

4. 在每个volatile读操作的后面插入一个LoadStore屏障。

1、StoreStore屏障可以保证在volatile写之前，其前面的所有普通写操作已经对任 意处理器可见了。这是因为StoreStore屏障将保障上面所有的普通写在volatile写之前刷新到主内存。

2、volatile写后面的StoreLoad屏障。此屏障的作用是避免volatile写与 后面可能有的volatile读/写操作重排序。因为编译器常常无法准确判断在一个volatile写的后面 是否需要插入一个StoreLoad屏障（比如，一个volatile写之后方法立即return）。为了保证能正确 实现volatile的内存语义，JMM在采取了保守策略：在每个volatile写的后面，或者在每个volatile 读的前面插入一个StoreLoad屏障。

锁的内存语义

1. 当线程释放锁时，JMM会把该线程对应的本地内存中的共享变量刷新到主内存中。

2. 当线程获取锁时，JMM会把该线程对应的本地内存置为无效。从而使得被监视器保护的 临界区代码必须从主内存中读取共享变量。

锁内存语义的实现

在Java的ReentrantLock锁中，现依赖于Java同步器框架AbstractQueuedSynchronizer（AQS），其中AQS使用一个整型的volatile变量（命名为state）来维护同步状态，马上我们会看到，这 个volatile变量是ReentrantLock内存语义实现的关键。

其中在锁获取和锁释放的时候，通过使用unsafe.compareAndSwapInt来原子更新state变量，此操作具有volatile读和写的内存语义。

其中在intel X86处理器中，compareAndSwapInt在openjdk中依次调用的c++代码为： unsafe.cpp，atomic.cpp和atomic_windows_x86.inline.hpp。其中调用的源代码如下：

inline jint Atomic::cmpxchg (jint exchange_value, volatile jint* dest,
jint compare_value) {
    // alternative for InterlockedCompareExchange
    int mp = os::is_MP();
    __asm {
        mov edx, dest
        mov ecx, exchange_value
        mov eax, compare_value
        LOCK_IF_MP(mp) // 根据当前处理器的类型来决定是否为cmpxchg指令添加lock前 缀
        cmpxchg dword ptr [edx], ecx
    }
}

其中LOCK_IF_MP会根据当前处理器的类型来决定是否为cmpxchg指令添加lock前 缀。如果程序是在多处理器上运行，就为cmpxchg指令加上lock前缀（Lock Cmpxchg）。反之，如 果程序是在单处理器上运行，就省略lock前缀（单处理器自身会维护单处理器内的顺序一致 性，不需要lock前缀提供的内存屏障效果）。

intel的手册对lock前缀的说明如下：

1）确保对内存的读-改-写操作原子执行。在Pentium及Pentium之前的处理器中，带有lock前 缀的指令在执行期间会锁住总线，使得其他处理器暂时无法通过总线访问内存。很显然，这会 带来昂贵的开销。从Pentium 4、Intel Xeon及P6处理器开始，Intel使用缓存锁定（Cache Locking） 来保证指令执行的原子性。缓存锁定将大大降低lock前缀指令的执行开销。

2）禁止该指令，与之前和之后的读和写指令重排序。

3）把写缓冲区中的所有数据刷新到内存中。

final域的内存语义

final域的重排序规则

对于final域，编译器和处理器要遵守两个重排序规则：

1. 在构造函数内对一个final域的写入，与随后把这个被构造对象的引用赋值给一个引用 变量，这两个操作之间不能重排序。

2. 初次读一个包含final域的对象的引用，与随后初次读这个final域，这两个操作之间不能 重排序。

这里需要注意以下：其中final成员常量的引用，可以在构造函数中进行初始化，但是在构造函数中进行存储化的时候可以被构造函数或者被其他线程读取到，所以这就会导致在初始化之前被读取到导致数据不一致的问题。

写final域的重排序规则

写final域的重排序规则禁止把final域的写重排序到构造函数之外：

1. JMM禁止编译器把final域的写重排序到构造函数之外。

2. 编译器会在final域的写之后，构造函数return之前，插入一个StoreStore屏障。这个屏障 禁止处理器把final域的写重排序到构造函数之外。

读final域的重排序规则

读final域的重排序规则是，在一个线程中，初次读对象引用与初次读该对象包含的final 域，JMM禁止处理器重排序这两个操作（注意，这个规则仅仅针对处理器）。编译器会在读final 域操作的前面插入一个LoadLoad屏障。

单例模式-双重锁检测

public class DoubleCheckedLocking {                       // 1
    private static Instance instance;                     // 2
    public static Instance getInstance() {                // 3
        if (instance == null) {                           // 4:第一次检查
            synchronized (DoubleCheckedLocking.class) {   // 5:加锁
                if (instance == null)                     // 6:第二次检查
                    instance = new Instance();            // 7:问题的根源出在这里
            }                                             // 8
        }                                                 // 9
        return instance;                                  // 10
    }                                                     // 11
}

如上是一个双重锁检测的场景，其中第7行代码有问题，会导致代码读取到instance不为null时，instance引用的对象有可能还没有完成初始化。

因为JAVA中实例化对应的操作，其实拆解为以下步骤：

memory = allocate();  // 1：分配对象的内存空间
ctorInstance(memory); // 2：初始化对象
instance = memory;    // 3：设置instance指向刚分配的内存地址

其中第二行和第三方发生了重排序之后, 就可能会导致引用变量指向了申请的内存区域的引用，但是内存区域还没进行初始化，则在其他线程读取到不为null但是却未初始化，则会出现问题。

其中有以下两种解决方案：

1.使用volatile来解决

public class SafeDoubleCheckedLocking {
    private volatile static Instance instance;
    public static Instance getInstance() {
        if (instance == null) {
            synchronized (SafeDoubleCheckedLocking.class) {
                if (instance == null)
                instance = new Instance(); // instance为volatile，现在没问题了
            }
        }
        return instance;
    }
}

2.使用类初始化来解决，JVM在类的初始化阶段（即在Class被加载后，且被线程使用之前），会执行类的初始化。在 执行类的初始化期间，JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。

public class InstanceFactory {
    private static class InstanceHolder {
        public static Instance instance = new Instance();
    }
    public static Instance getInstance() {
        return InstanceHolder.instance ; // 这里将导致InstanceHolder类被初始化
    }
}

Synchronized的实现原理与应用

从JVM规范中可以看到Synchonized在JVM里的实现原理，JVM基于进入和退出Monitor对 象来实现方法同步和代码块同步，但两者的实现细节不一样。代码块同步是使用monitorenter 和monitorexit指令实现的，而方法同步是使用另外一种方式实现的，细节在JVM规范里并没有 详细说明。但是，方法的同步同样可以使用这两个指令来实现。

monitorenter指令是在编译后插入到同步代码块的开始位置，而monitorexit是插入到方法结 束处和异常处，JVM要保证每个monitorenter必须有对应的monitorexit与之配对。任何对象都有 一个monitor与之关联，当且一个monitor被持有后，它将处于锁定状态。线程执行到monitorenter 指令时，将会尝试获取对象所对应的monitor的所有权，即尝试获得对象的锁。

Java对象头

synchronized用的锁是存在Java对象头里的。如果对象是数组类型，则虚拟机用3个字宽 （Word）存储对象头，如果对象是非数组类型，则用2字宽存储对象头。在32位虚拟机中，1字宽 等于4字节，即32bit。

长度	内容	说明
32/64bit	Mark Word	存储对象的hashcode和锁信息
32/64bit	Class Metadata Address	存储到对象数据类型的指针
32/64bit	Array Length	数组的长度（如果当前对象是数组）

Java对象头里的Mark Word里默认存储对象的HashCode、分代年龄和锁标记位：

锁状态	25bit	4bit	1bit是否是偏向锁	2bit锁标志位
无锁状态	对象的hashcode	对象分代年龄	0	01

在运行期间，Mark Word里存储的数据会随着锁标志位的变化而变化。Mark Word可能变 化为存储以下4种数据：

锁的升级与对比

Java SE 1.6为了减少获得锁和释放锁带来的性能消耗，引入了“偏向锁”和“轻量级锁”，在 Java SE 1.6中，锁一共有4种状态，级别从低到高依次是：无锁状态、偏向锁状态、轻量级锁状 态和重量级锁状态，这几个状态会随着竞争情况逐渐升级。锁可以升级但不能降级，意味着偏 向锁升级成轻量级锁后不能降级成偏向锁。这种锁升级却不能降级的策略，目的是为了提高 获得锁和释放锁的效率。

偏向锁

1.获取偏向锁：大多数情况下，锁不仅不存在多线程竞争，而且总是由同 一线程多次获得，为了让线程获得锁的代价更低而引入了偏向锁。当一个线程访问同步块并 获取锁时，会在对象头和栈帧中的锁记录里存储锁偏向的线程ID，以后该线程在进入和退出 同步块时不需要进行CAS操作来加锁和解锁，只需简单地测试一下对象头的Mark Word里是否 存储着指向当前线程的偏向锁。如果测试成功，表示线程已经获得了锁。如果测试失败，则需 要再测试一下Mark Word中偏向锁的标识是否设置成1（表示当前是偏向锁）：如果没有设置，则 使用CAS竞争锁；如果设置了，则尝试使用CAS将对象头的偏向锁指向当前线程。

2.撤销偏向锁：偏向锁使用了一种等到竞争出现才释放锁的机制，所以当其他线程尝试竞争偏向锁时， 持有偏向锁的线程才会释放锁。偏向锁的撤销，需要等待全局安全点（在这个时间点上没有正 在执行的字节码）。它会首先暂停拥有偏向锁的线程，然后检查持有偏向锁的线程是否活着， 如果线程不处于活动状态，则将对象头设置成无锁状态；如果线程仍然活着，拥有偏向锁的栈 会被执行，遍历偏向对象的锁记录，栈中的锁记录和对象头的Mark Word要么重新偏向于其他 线程，要么恢复到无锁或者标记对象不适合作为偏向锁，最后唤醒暂停的线程。图2-1中的线 程1演示了偏向锁初始化的流程。

3.关闭偏向锁：偏向锁在Java 6和Java 7里是默认启用的，但是它在应用程序启动几秒钟之后才激活，如 有必要可以使用JVM参数来关闭延迟：-XX:BiasedLockingStartupDelay=0。如果你确定应用程 序里所有的锁通常情况下处于竞争状态，可以通过JVM参数关闭偏向锁：-XX:- UseBiasedLocking=false，那么程序默认会进入轻量级锁状态。

轻量级锁

1.轻量级锁加锁：线程在执行同步块之前，JVM会先在当前线程的栈桢中创建用于存储锁记录的空间，并 将对象头中的Mark Word复制到锁记录中，官方称为Displaced Mark Word。然后线程尝试使用 CAS将对象头中的Mark Word替换为指向锁记录的指针。如果成功，当前线程获得锁，如果失 败，表示其他线程竞争锁，当前线程便尝试使用自旋来获取锁。

2.轻量级锁解锁：轻量级解锁时，会使用原子的CAS操作将Displaced Mark Word替换回到对象头，如果成 功，则表示没有竞争发生。如果失败，表示当前锁存在竞争，锁就会膨胀成重量级锁。因为自旋会消耗CPU，为了避免无用的自旋（比如获得锁的线程被阻塞住了），一旦锁升级 成重量级锁，就不会再恢复到轻量级锁状态。当锁处于这个状态下，其他线程试图获取锁时， 都会被阻塞住，当持有锁的线程释放锁之后会唤醒这些线程，被唤醒的线程就会进行新一轮 的夺锁之争。

锁的优缺点对比

锁	优点	缺点	适用场景
偏向锁	加锁和解锁不需要额外的消耗，和执行非同步方法相比仅存在纳秒级差距	当线程间存在锁竞争会带来额外的锁撤销消耗	适用于只有一个线程访问同步代码的场景
轻量级锁	竞争的线程不会阻塞，提高了响应速度	如果始终得不到锁竞争的线程，自旋会消耗CPU	追求响应时间，同步块执行速度快
重量级锁	县城竞争不使用自旋，不消耗cpu	线程阻塞，响应时间缓慢	追求吞吐量，同步块执行速度较慢。

原子操作的实现原理

Cpu术语定义：

术语名称	英文	说明
缓存行	cache line	缓存的最小操作单位
比较并交换	compare and set	cas操作需要输入两个值，一个旧值和一个新值，在操作期间当旧值没有发生变化，才设置新值，否则不执行操作
cpu流水线	cpu pipeline	cpu流水线工作方式像生产线上的装配流水线，在cpu种由5~6个不通功能的电路单元组成一条指令处理流水线，然后将一条X86指令分成5~6步后再由这些电路单元分别执行，这样就实现在一个cpu时钟周期完成一条指令，因此提高cpu的运算速度。
内存顺序冲突	memory order violation	内存顺序冲突一般由于伪共享引起的，伪共享是指多个cpu同时修改同一缓存行的不通部分引起其中一个cpu的操作无效的情况，当出现这种情况时，cpu必须清空流水线。

处理器如何实现原子操作

1.使用总线锁保证原子性:总线锁就是使用处理器提供的一个 LOCK＃信号，当一个处理器在总线上输出此信号时，其他处理器的请求将被阻塞住，那么该 处理器可以独占共享内存。总线锁定把CPU和内存之间的通信锁住了，这使得锁定期间，其他处 理器不能操作其他内存地址的数据，所以总线锁定的开销比较大，目前处理器在某些场合下 使用缓存锁定代替总线锁定来进行优化。

2.使用缓存锁保证原子性：内存区域如果被缓存在处理器的缓存 行中，并且在Lock操作期间被锁定，那么当它执行锁操作回写到内存时，处理器不在总线上声 言LOCK＃信号，而是修改内部的内存地址，并允许它的缓存一致性机制来保证操作的原子 性，因为缓存一致性机制会阻止同时修改由两个以上处理器缓存的内存区域数据，当其他处 理器回写已被锁定的缓存行的数据时，会使缓存行无效。

JAVA并发编程基础

线程

现代操作系统在运行一个程序时，会为其创建一个进程。例如，启动一个Java程序，操作 系统就会创建一个Java进程。现代操作系统调度的最小单元是线程，也叫轻量级进程（Light Weight Process），在一个进程里可以创建多个线程，这些线程都拥有各自的计数器、堆栈和局 部变量等属性，并且能够访问共享的内存变量。处理器在这些线程上高速切换，让使用者感觉 到这些线程在同时执行。

线程优先级

在Java线程中，通过一个整型成员变量priority来控制优先级，优先级的范围从1~10，在线 程构建的时候可以通过setPriority(int)方法来修改优先级，默认优先级是5，优先级高的线程分 配时间片的数量要多于优先级低的线程。设置线程优先级时，针对频繁阻塞（休眠或者I/O操 作）的线程需要设置较高优先级，而偏重计算（需要较多CPU时间或者偏运算）的线程则设置较 低的优先级，确保处理器不会被独占。在不同的JVM以及操作系统上，线程规划会存在差异， 有些操作系统甚至会忽略对线程优先级的设定。

线程状态

public enum State {
        /**
         * 线程被创建了但是还没有调用Start()。
         */
        NEW,
​
        /**
         * 运行状态，Java中将就绪和运行两种状态笼统称为“运行中”。
         */
        RUNNABLE,
​
        /**
         * 阻塞状态，表示线程阻塞于锁。
         */
        BLOCKED,
​
        /**
         * 等待状态, 调用Object.wait|Thread.join|LockSupport.park等进入该状态,等待其他线程执行特定的动作。
         */
        WAITING,
​
        /**
         * 超时等待状态,调用Thread.sleep|Object.wait|Thread.join|LockSupport.parkNanos|LockSupport.parkUntil进入该状态,可以
         * 在指定的时间之后返回。
         */
        TIMED_WAITING,
​
        /**
         * 终止状态,线程已经执行完毕
         */
        TERMINATED;
}

Daemon线程：Daemon线程是一种支持型线程，因为它主要被用作程序中后台调度以及支持性工作。这 意味着，当一个Java虚拟机中不存在非Daemon线程的时候，Java虚拟机将会退出。可以通过调 用Thread.setDaemon(true)将线程设置为Daemon线程。

线程中断

中断可以理解为线程的一个标识位属性，它表示一个运行中的线程是否被其他线程进行 了中断操作。要中断一个线程通常调用Thread.interrupt()，然后调用Thread.isInterrupted判断是否被中断，线程通过检查自身是否被中断来进行响应，线程通过方法isInterrupted()来进行判断是否 被中断，也可以调用静态方法Thread.isInterrupted()对当前线程的中断标识位进行复位。如果该 线程已经处于终结状态，即使该线程被中断过，在调用该线程对象的isInterrupted()时依旧会返 回false。

线程/等待和通知机制

方法	说明
Object.wait()	调用该方法的线程进入等待WAITTING状态，只有等待另外的线程通知或者中断才能返回，注意：Wait和Synchronized组合使用，这会释放持有的锁。
Object.wait(long)	超时等待一段时间，毫秒级别。
Object.wait(long, int)	超时等待一段时间，更精细纳秒级别。
Object.notify()	通知等待在对象的一个线程，使其从wait()返回，返回的前提是该线程获得了对象的锁。
Object.notifyAll()	通知等待在对象上的所有线程，这会把把等待队列的线程全部移动到同步队列中去。