一、并发和并行

并发和并行的目的都是最大化的使用CUP
并行(parallel)： 指在同一时刻，有多条指令在多个处理器上同时执行。所以无论从微观还是 从宏观来看，二者都是一起执行的。
并发(concurrency)： 指在同一时刻只能有一条指令执行，但多个进程指令被快速的轮换执行，使得在宏观上具有多个进程同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干段，使多个进程快速交替的执行，每个指令的执行时间在10ms-100ms之间，使用户感知不到。
并行在多处理器系统中存在，而并发可以在单处理器和多处理器系统中都存在，并发能够在单处理器系统中存在是因为并发是并行的假象，并行要求程序能够同时执行多个操作，而并发只是要求程序假装同时执行多个操作，这里有多种算法来分配。（每个小时间片执行一个操作，多个操作快速切换执行）

二、并发三大特性

1、可见性

当一个线程修改了一个共享变量的值，其他的线程可以看到修改后的结果。
Java 内存模型是通过在变量修改后将新值同步回主内存，在变量读取前从主内存刷新变量值这种依赖主内存作为传递媒介的方法来实现可见性的。
可以保证可见性的操作：
1、volatile 关键字
2、内存屏障
3、synchronized 关键字
4、Lock指令
5、final 关键字
可见性的代码示例：
代码中 线程A 执行的方法相当于while(true) ，这个优先级非常高，几乎不会让出cup时间，那么 线程B 在执行时必然会在另外一个cup上执行。
这里可能会出现由于线程优先级出现的死锁，例如 线程A 先获取了锁，然后线程B执行，由于 线程B 的优先级过高导致 线程A 获取不到时间片无法继续执行，导致 线程A 无法释放锁，别的线程也无法获取锁。

  1. public class VisibilityTest {
  2.     // 1、使用volatile关键字，基于JVM内存屏障 storeload
  3.     // private volatile boolean flag = true;
  4.     private boolean flag = true;
  5.     // 6、给count共享变量增加 volatile 关键字
  6.     // private volatile int count = 0;
  7.     // 7、给count共享变量改变类型为包装类
  8.     // private Integer count = 0;
  9.     private int count = 0;
  11.     public void refresh() {
  12.         flag = false;
  13.         System.out.println(Thread.currentThread().getName() + "修改flag:"+flag);
  14.     }
  16.     public void load() {
  17.         System.out.println(Thread.currentThread().getName() + "开始执行.....");
  18.         // 这里相当于while(true) 的循环，这个循环的优先级非常高，几乎不会让出cup时间片
  19.         while (flag) {
  20.             // TODO 业务逻辑
  21.             count++;
  22.             // 2、显示调用内存屏障
  23.             //UnsafeFactory.getUnsafe().storeFence();
  24.             // 3、让出cup时间片，线程上下文切换，程序计数器会记录下一行指令
  25.             //Thread.yield();
  26.             // 4、打印日志，打印日志底层使用synchronized，底层也是内存屏障storeFence()
  27.             //System.out.println(count);
  28.             // 5、unpark 给线程发放许可，使用内存屏障
  29.             //LockSupport.unpark(Thread.currentThread());
  30.             // 8、方法执行时间过长，由于工作内存空间有限，所以flag在工作内存中会被淘汰
  31.             // 下次加载的时候会从主内存中加载，就可以读到修改过的值
  32.             //shortWait(1000000); //1ms
  33.             // 时间过短的话则不会被淘汰
  34.             //shortWait(1000);
  36. //            try {
  37. //                Thread.sleep(1);   //内存屏障
  38. //            } catch (InterruptedException e) {
  39. //                e.printStackTrace();
  40. //            }
  41.         }
  42.         System.out.println(Thread.currentThread().getName() + "跳出循环: count=" + count);
  43.     }
  45.     public static void main(String[] args) throws InterruptedException {
  46.         VisibilityTest test = new VisibilityTest();
  48.         // 线程threadA模拟数据加载场景
  49.         Thread threadA = new Thread(() -> test.load(), "threadA");
  50.         threadA.start();
  52.         // 让threadA执行一会儿
  53.         Thread.sleep(1000);
  54.         // 线程threadB通过flag控制threadA的执行时间
  55.         Thread threadB = new Thread(() -> test.refresh(), "threadB");
  56.         threadB.start();
  58.     }
  61.     public static void shortWait(long interval) {
  62.         long start = System.nanoTime();
  63.         long end;
  64.         do {
  65.             end = System.nanoTime();
  66.         } while (start + interval >= end);
  67.     }
  68. }

线程A 需要一个共享变量 flag 来判断是否继续循环，线程B 会把这个共享变量 flag 改为 false，但是即便 线程B 修改了flag，线程A 也不会停止循环，因为 线程A 没有感知到flag的修改，也就是flag 对 线程A 不可见。
注意：关于方法执行时间过长，缓存淘汰这种方式是不可控的，无法完全保证可见性，这种方式会受到各种情况的影响，具体情况无法穷举，所以需要使用volatile关键字保证可见性。

2、有序性

即程序执行的顺序按照代码的先后顺序执行。JVM 存在指令重排，所以存在有序性问题。
如何保证有序性：
1、volatile 关键字
2、内存屏障
3、synchronized关键字
4、Lock指令

3、原子性

一个或多个操作，要么全部执行且在执行过程中不被任何因素打断，要么全部不执行。在 Java 中，对基本数据类型的变量的读取和赋值操作是原子性操作（64位处理器）。不采取任 何的原子性保障措施的自增操作并不是原子性的。
如何保证原子性：
1、synchronized 关键字
2、Lock指令
3、CAS

三、JMM模型

1、JMM定义

对于可见性问题，需要分析JMM（Java Memory Model）模型，这个模型属于java内存模型，线程与线程间通信有关，是一个共享内存模型。用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效 果，JMM规范了Java虚拟机与计算机内存是如何协同工作的：规定了一个线程如何和何时可以看到由其他线程修改过后的共享变量的值，以及在必须时如何同步的访问共享变量。JMM描述的是一种抽象的概念，一组规则，通过这组规则控制程序中各个变量在共享数据区域和私有数据区域的访问方式，JMM是围绕原子性、有序性、可见性展开的。
1.png图中，线程A 和 线程B 想要交换数据，就需要通过主内存。例如 线程A 把变量 x 的值修改为 5，那么首先线程A就要把 x = 5 写到本地内存，再保存到主内存。此时 线程B 就可以从主内存中读取 x = 5。
图中的本地内存和主内存是一个逻辑空间，并不是特指某一个固定的内存区域，在内存、寄存器和高速缓存中都有本地内存和主内存的概念。
Java内存模型与硬件内存架构之间存在差异。硬件内存架构没有区分线程栈和堆。对于硬 件，所有的线程栈和堆都分布在主内存中。部分线程栈和堆可能有时候会出现在CPU缓存中和 CPU内部的寄存器中。如下图所示，Java内存模型和计算机硬件内存架构是一个交叉关系：
3.png

2、 内存交互操作

在可见性中的代码，在JMM内存模型中变量的读写流程和导致内存不可见的原因，见下图：
2.png从图中可以看出，一个变量从主存读到cpu，经过了一些内存操作，这些操作都是原子性的。
线程A 从主内存中经过 read 操作读取了 flag = true，再使用 load 操作赋值到本地内存，使用use 操作交给cpu处理，这时cpu开始while循环，由于cpu的优化，这里会判断 flag 变量在近期内会被用到，所以会一直在工作内存中短期内不会被淘汰，但是由于工作内存比较小，如果while循环执行时间过长，也会被淘汰掉，再从主内存读取，如果这时线程B已经把修改过的值刷回主内存，这种情况可以保证可见性。
线程B 从主内存中读取，写入工作内存，再交给cpu操作之后，assign 操作写回工作内存，store 读取工作内存，wirte 写回主内存，这里stroe 操作并不是实时的，也就是说并不是 assign 操作完写回工作内存就会写回主内存，变量在本地内存淘汰之前或线程结束之前会刷回主内存。
此时主内存的 flag 已经改为 false，但是线程A 并没有再读主内存，而是再使用工作内存中的副本变量，所以导致不可见问题。

3、java内存模型的八种基本操作

关于主内存与工作内存之间的具体交互协议，即一个变量如何从主内存拷贝到工作内存、 如何从工作内存同步到主内存之间的实现细节，Java内存模型定义了以下八种操作来完成：
lock（锁定）：作用于主内存的变量，把一个变量标识为一条线程独占状态。
unlock（解锁）：作用于主内存变量，把一个处于锁定状态的变量释放出来，释放 后的变量才可以被其他线程锁定。
read（读取）：作用于主内存变量，把一个变量值从主内存传输到线程的工作内存 中，以便随后的load动作使用
load（载入）：作用于工作内存的变量，它把read操作从主内存中得到的变量值放 入工作内存的变量副本中。
use（使用）：作用于工作内存的变量，把工作内存中的一个变量值传递给执行引 擎，每当虚拟机遇到一个需要使用变量的值的字节码指令时将会执行这个操作。
assign（赋值）：作用于工作内存的变量，它把一个从执行引擎接收到的值赋值给 工作内存的变量，每当虚拟机遇到一个给变量赋值的字节码指令时执行这个操作。
store（存储）：作用于工作内存的变量，把工作内存中的一个变量的值传送到主 内存中，以便随后的write的操作。
write（写入）：作用于主内存的变量，它把store操作从工作内存中一个变量的值 传送到主内存的变量中。
4.pngJava内存模型还规定了在执行上述八种基本操作时，必须满足如下规则：
1）如果要把一个变量从主内存中复制到工作内存，就需要按顺寻地执行read和load操作， 如果把变量从工作内存中同步回主内存中，就要按顺序地执行store和write操作。 但Java内存模型只要求上述操作必须按顺序执行，而没有保证必须是连续执行。
2）不允许read和load、store和write操作之一单独出现
3）不允许一个线程丢弃它的最近assign的操作，即变量在工作内存中改变了之后必须 同步到主内存中。
4）不允许一个线程无原因地（没有发生过任何assign操作）把数据从工作内存同步回 主内存中。
5）一个新的变量只能在主内存中诞生，不允许在工作内存中直接使用一个未被初始化（load或assign）的变量。即就是对一个变量实施use和store操作之前，必须先执行过了assign和load操作。
6）一个变量在同一时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。lock和unlock必须成对出现
7）如果对一个变量执行lock操作，将会清空工作内存中此变量的值，在执行引擎使用这个变量前需要重新执行load或assign操作初始化变量的值如果一个变量事先没有被lock操作锁定，则不允许对它执行unlock操作；也不允许去unlock一个被其他线程锁定的变量。
8）对一个变量执行unlock操作之前，必须先把此变量同步到主内存中（执行store和 write操作）。

4、 JMM的内存可见性保证

由上面代码的例子可以得到一个结论，想要保证内存的可见性，那么就必须让线程的工作内存失效，从主内存中重新去读。

1）Thread.yield()操作

这个操作 线程A 会让出cpu时间片，同时保存上下文即写回主存，程序计数器会记录下一行将要执行的指令，进行上下文的切换即线程切换，等别的线程执行完，这段时间 线程A 的变量在寄存器和缓存中会被淘汰，当 线程A 继续执行的时候会从程序计数器记录的指令开始执行，并从主存中读取数据，如果再切换上下文期间，主存的内容被别的线程修改了，那么此时 线程A 可以读到最新的内容。

2）volatile关键字

字节码解释器：
关键字需要字节码解释器来实具体的代码，例如 synchronized 关键字会在代码块中加 monitorenter。
JVM中的字节码解释器(bytecodeInterpreter)，用C++实现了JVM指令，其优点是实现相对 简单且容易理解，缺点是执行慢。 bytecodeInterpreter.cpp
5.png代码中，先判断是不是一个volatile修饰的，如果是，会加一个内存屏障 storeload()。这种JVM的内存屏障一共有四种：
LoadLoad屏障：（指令Load1; LoadLoad; Load2），在Load2及后续读取操作要读取的数 据被访问前，保证Load1要读取的数据被读取完毕。
LoadStore屏障：（指令Load1; LoadStore; Store2），在Store2及后续写入操作被刷出前， 保证Load1要读取的数据被读取完毕。
StoreStore屏障：（指令Store1; StoreStore; Store2），在Store2及后续写入操作执行前， 保证Store1的写入操作对其它处理器可见。
StoreLoad屏障：（指令Store1; StoreLoad; Load2），在Load2及后续所有读取操作执行 前，保证Store1的写入对所有处理器可见。它的开销是四种屏障中最大的。在大多数处理器的实现中，这个屏障是个万能屏障，兼具其它三种内存屏障的功能。
由于x86只有store load可能会重排序，所以只有JSR的StoreLoad屏障对应它的mfence或lock前缀指令，其他屏障对应空操作。
storeload在linux系统x86中的实现： orderAccess_linux_x86.inline.hpp
6.png
fence() 方法判断是不是多处理器架构，单处理器不存在这个问题，如果是多核的处理器，那么会增加一个汇编曾名指令 lock; addl $0,0(%%rsp)，这是一个lock前缀指令，lock前缀指令不是内存屏障的指令，但是有内存屏障的效果，在x86中内存屏障是使用lock来实现，lock前缀指令比mfence（内存屏障）性能好一些。
lock除了有内存屏障的效果（立即刷回主存）外，还可以使其他的在缓存中的副本内容失效，使其他线程重新读取主内存。
如此使得volatile保证了可见性。
模板解释器：
在java中对一些常用的关键字做了优化，volatile 就是使用这种方式实现的。
模板解释器(templateInterpreter)，其对每个指令都写了一段对应的汇编代码，启动时将每个指令与对应汇编代码入口绑定，可以说是效率做到了极致。 templateTable_x86_64.cpp
7.png8.png在给属性赋值的时候，会执行 void TemplateTable::putfield_or_static 这个方法中会执行 volatile_barrier(Assembler::Membar_mask_bits(Assembler::StoreLoad | Assembler::StoreStore)); 增加 StoreLoad JVM内存屏障，在 StoreLoad 中会调用membar 方法。
9.png最后会调用lock() 方法，就是执行lock前缀指令。

3）final关键字

代码中如果把count共享变量的类型改为Integer类型的话，也是内存可见的。因为 Integer 是不可变类，值是不变的，也就是final 修饰的。JMM对 final 也做了优化，所以线程对不变的也会保证可见性。但是final是只读的，所以存在一定的限制与效率问题，所以一般不会用来作为保证可见性的方式。

4）总结

总体来说，想要保证内存的可见性有两种方式：
内存屏障：这个是JVM层面，调用storeload，在x86环境中，使用lock代替了mfence
上下文切换：使线程让出cpu，等待唤醒机制，park，unpark

5、 lock前缀指令的作用

1）确保后续指令执行的原子性。在Pentium及之前的处理器中，带有lock前缀的指令在执行期间会锁住总线，使得其它处理器暂时无法通过总线访问内存，很显然，这个开销很大。在新的处理器中，Intel使用缓存锁定来保证指令执行的原子性，缓存锁定将大大降低 lock前缀指令的执行开销。
2）LOCK前缀指令具有类似于内存屏障的功能，禁止该指令与前面和后面的读写指令重排序。
3）LOCK前缀指令会等待它之前所有的指令完成、并且所有缓冲的写操作写回内存(也就是将store buffer中的内容写入内存)之后才开始执行，并且根据缓存一致性协议，刷新store buffer的操作会导致其他cache中的副本失效。

6、 从硬件层面分析Lock前缀指令

32位的IA-32处理器支持对系统内存中的位置进行锁定的原子操作。这些操作通常用于管 理共享的数据结构(如信号量、段描述符、系统段或页表)，在这些结构中，两个或多个处理器可能同时试图修改相同的字段或标志。处理器使用三种相互依赖的机制来执行锁定的原子操作:
1）总线裁决机制，有保证读、写操作的原子性。
2）总线锁定，使用LOCK#信号和LOCK指令前缀。
3）缓存一致性协议，确保原子操作可以在缓存的数据结构上执行(缓存锁);这种机制出现在Pentium 4、Intel Xeon和P6系列处理器中。