java内存模型与线程

java内存模型

Java内存模型（Java Memory Model,JMM）屏蔽掉各种硬件和操作系统的内存访问差异，实现让Java程序在各种平台下都能达到一致的内存访 问效果。在此之前，主流程序语言（如C/C++等）直接使用物理硬件和操作系统的内存模 型，因此，会由于不同平台上内存模型的差异，有可能导致程序在一套平台上并发完全正 常，而在另外一套平台上并发访问却经常出错，因此在某些场景就必须针对不同的平台来编 写程序。

java内存模型 与硬件操作系统的缓存模型可以类比

硬件系统的缓存模型

java 内存模型

注意：
java内存模型(JMM)与Java内存区域划分中的Java堆、栈、方法区 等并不是同一个层次的内存划分，这两者基本上是没有关系的，如果两者一定要勉强对应起 来，那从变量、主内存、工作内存的定义来看，主内存主要对应于Java堆中的对象实例数据 部分，而工作内存则对应于虚拟机栈中的部分区域。从更低层次上说，主内存就直接对应 于物理硬件的内存，而为了获取更好的运行速度，虚拟机（甚至是硬件系统本身的优化措 施）可能会让工作内存优先存储于寄存器和高速缓存中，因为程序运行时主要访问读写的是 工作内存。

内存间交互操作

Java内存模型定义了以下8种操作来 完成，虚拟机实现时必须保证下面提及的每一种操作都是原子的、不可再分的。

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

Java内存模型还规定了在执行上述8种 基本操作时必须满足如下规则：

• 不允许read和load、store和write操作之一单独出现，即不允许一个变量从主内存读取了
  但工作内存不接受，或者从工作内存发起回写了但主内存不接受的情况出现。

• 不允许一个线程丢弃它的最近的assign操作，即变量在工作内存中改变了之后必须把该 变化同步回主内存。

• 不允许一个线程无原因地（没有发生过任何assign操作）把数据从线程的工作内存同步 回主内存中。

• 一个新的变量只能在主内存中“诞生”，不允许在工作内存中直接使用一个未被初始化 （load或assign）的变量，换句话说，就是对一个变量实施use、store操作之前，必须先执行 过了assign和load操作。

• 一个变量在同一个时刻只允许一条线程对其进行lock操作，但lock操作可以被同一条线 程重复执行多次，多次执行lock后，只有执行相同次数的unlock操作，变量才会被解锁。 如果对一个变量执行lock操作，那将会清空工作内存中此变量的值，在执行引擎使用这 个变量前，需要重新执行load或assign操作初始化变量的值。

• 如果一个变量事先没有被lock操作锁定，那就不允许对它执行unlock操作，也不允许去 unlock一个被其他线程锁定住的变量。 对一个变量执行unlock操作之前，必须先把此变量同步回主内存中（执行store、write操 作）

对于volatile型变量的特殊规则

关键字volatile可以说是Java虚拟机提供的最轻量级的同步机制，但是它并不容易完全被 正确、完整地理解，以至于许多程序员都习惯不去使用它，遇到需要处理多线程数据竞争问 题的时候一律使用synchronized来进行同步。

当一个变量定义为volatile之后，它将具备两种特性

1. 第一是保证此变量对所有线程的可 见性，这里的“可见性”是指当一条线程修改了这个变量的值，新值对于其他线程来说是可以 立即得知的。
2. 第二个语义是禁止指令重排序优化

对于long和double型变量的特殊规则

对于64位的数据类型（long和double），在模型中特别定义了一条相对宽松的 规定：允许虚拟机将没有被volatile修饰的64位数据的读写操作划分为两次32位的操作来进 行，即允许虚拟机实现选择可以不保证64位数据类型的load、store、read和write这4个操作的 原子性，这点就是所谓的long和double的非原子性协定

目前各种平台下的商用虚拟机几乎都选择把64位数据的读写操作作为原子操作来对待， 因此我们在编写代码时一般不需要把用到的long和double变量专门声明为volatile

原子性 可见性 有序性

1. 原子性
   由Java内存模型来直接保证的原子性变量操作包括read、load、 assign、use、store和write；
   lock unlock 操作由同步块synchronized关键字实现

2. 可见性
   volatile关键字 synchronized关键字 final关键字 能实现可见性

3. 有序性
   volatile和synchronized两个关键字来保证线程之间操作的有序性

先行发生原则

Java语言无须任何同步手段保障就能成立的先行发生规则

1. 程序次序规则（Program Order Rule）：准确地说，应该是控制流顺序而不是程序代码顺序， 因为要考虑分支、循环等结构。
2. 管程锁定规则（Monitor Lock Rule）：一个unlock操作先行发生于后面对同一个锁的lock 操作。这里必须强调的是同一个锁，而“后面”是指时间上的先后顺序。
3. volatile变量规则（Volatile Variable Rule）：对一个volatile变量的写操作先行发生于后面 对这个变量的读操作，这里的“后面”同样是指时间上的先后顺序。
4. 线程启动规则（Thread Start Rule）：Thread对象的start（）方法先行发生于此线程的每 一个动作。
5. 线程终止规则（Thread Termination Rule）：线程中的所有操作都先行发生于对此线程的终止检测，我们可以通过Thread.join（）方法结束、Thread.isAlive（）的返回值等手段检测 到线程已经终止执行。
6. 线程中断规则（Thread Interruption Rule）：对线程interrupt（）方法的调用先行发生于被 中断线程的代码检测到中断事件的发生，可以通过Thread.interrupted（）方法检测到是否有 中断发生。
7. 对象终结规则（Finalizer Rule）：一个对象的初始化完成（构造函数执行结束）先行发 生于它的finalize（）方法的开始。
8. 传递性（Transitivity）：如果操作A先行发生于操作B，操作B先行发生于操作C，那就 可以得出操作A先行发生于操作C的结论。

线程

线程是比进程更轻量级的调度执行单位，线程的引入，可以把一个进程的资 源分配和执行调度分开，各个线程既可以共享进程资源（内存地址、文件I/O等），又可以 独立调度（线程是CPU调度的基本单位）。

主流的操作系统都提供了线程实现，Java语言则提供了在不同硬件和操作系统平台下对 线程操作的统一处理，每个已经执行start（）且还未结束的java.lang.Thread类的实例就代表 了一个线程。

Thread类与大部分的Java API有显著的差别，它的所有关键方法都 是声明为Native的。在Java API中，一个Native方法往往意味着这个方法没有使用或无法使用 平台无关的手段来实现（当然也可能是为了执行效率而使用Native方法，不过，通常最高效 率的手段也就是平台相关的手段）。

线程的实现

实现线程主要有3种方式：使用内核线程实现、使用用户线程实现和使用用户线程加轻 量级进程混合实现。

1. 使用内核线程实现
   内核线程（Kernel-Level Thread,KLT）就是直接由操作系统内核（Kernel，下称内核）支 持的线程，这种线程由内核来完成线程切换，内核通过操纵调度器（Scheduler）对线程进行 调度，并负责将线程的任务映射到各个处理器上。
   程序一般不会直接去使用内核线程，而是去使用内核线程的一种高级接口——轻量级进 程（Light Weight Process,LWP），轻量级进程就是我们通常意义上所讲的线程，由于每个轻 量级进程都由一个内核线程支持，因此只有先支持内核线程，才能有轻量级进程。这种轻量 级进程与内核线程之间1:1的关系称为一对一的线程模型
   
   是轻量级进程具有它的局限 性：首先，由于是基于内核线程实现的，所以各种线程操作，如创建、析构及同步，都需要 进行系统调用。而系统调用的代价相对较高，需要在用户态（User Mode）和内核态（Kernel Mode）中来回切换。其次，每个轻量级进程都需要有一个内核线程的支持，因此轻量级进 程要消耗一定的内核资源（如内核线程的栈空间），因此一个系统支持轻量级进程的数量是 有限的。

2.使用用户线程实现
而狭义上的用户线程指的是完全建立在用户空间的线程库上，系统内核不能感知线程存 在的实现。用户线程的建立、同步、销毁和调度完全在用户态中完成，不需要内核的帮助。 如果程序实现得当，这种线程不需要切换到内核态，因此操作可以是非常快速且低消耗的， 也可以支持规模更大的线程数量，部分高性能数据库中的多线程就是由用户线程实现的。这 种进程与用户线程之间1：N的关系称为一对多的线程模型

1. 使用用户线程加轻量级进程混合实现
   将内核线程与用 户线程一起使用的实现方式。在这种混合实现下，既存在用户线程，也存在轻量级进程。用 户线程还是完全建立在用户空间中，因此用户线程的创建、切换、析构等操作依然廉价，并 且可以支持大规模的用户线程并发。而操作系统提供支持的轻量级进程则作为用户线程和内 核线程之间的桥梁，这样可以使用内核提供的线程调度功能及处理器映射，并且用户线程的 系统调用要通过轻量级线程来完成，大大降低了整个进程被完全阻塞的风险。在这种混合模 式中，用户线程与轻量级进程的数量比是不定的，即为N：M的关系
   

java线程的实现

操作系统支持怎样的线程模型，在很大程度上决定了Java虚拟机的线程是怎样映射 的，这点在不同的平台上没有办法达成一致，虚拟机规范中也并未限定Java线程需要使用哪 种线程模型来实现。线程模型只对线程的并发规模和操作成本产生影响，对Java程序的编码 和运行过程来说，这些差异都是透明的。

Java线程调度

线程调度是指系统为线程分配处理器使用权的过程，主要调度方式有两种，分别是协同 式线程调度（Cooperative Threads-Scheduling）和抢占式线程调度（Preemptive Threads- Scheduling）。

Java语言定义了5种线程状态

1. 新建（New）：创建后尚未启动的线程处于这种状态。
2. 运行（Runable）：Runable包括了操作系统线程状态中的Running和Ready，也就是处于此 状态的线程有可能正在执行，也有可能正在等待着CPU为它分配执行时间。
3. 无限期等待（Waiting）：处于这种状态的线程不会被分配CPU执行时间，它们要等待被 其他线程显式地唤醒。以下方法会让线程陷入无限期的等待状态：
   ●没有设置Timeout参数的Object.wait（）方法。
   ●没有设置Timeout参数的Thread.join（）方法。
   ●LockSupport.park（）方法。
4. 限期等待（Timed Waiting）：处于这种状态的线程也不会被分配CPU执行时间，不过无 须等待被其他线程显式地唤醒，在一定时间之后它们会由系统自动唤醒。以下方法会让线程 进入限期等待状态：
   ●Thread.sleep（）方法。
   ●设置了Timeout参数的Object.wait（）方法。
   ●设置了Timeout参数的Thread.join（）方法。
   ●LockSupport.parkNanos（）方法。
   ●LockSupport.parkUntil（）方法。
5. 阻塞（Blocked）：线程被阻塞了，“阻塞状态”与“等待状态”的区别是：“阻塞状态”在等 待着获取到一个排他锁，这个事件将在另外一个线程放弃这个锁的时候发生；而“等待状 态”则是在等待一段时间，或者唤醒动作的发生。在程序等待进入同步区域的时候，线程将 进入这种状态。
6. 结束（Terminated）：已终止线程的线程状态，线程已经结束执行。