关于后端:JVM关于JVM你需要掌握这些-一文彻底吃透JVM系列

最近，始终有小伙伴让我整顿下对于 JVM 的常识，通过十几天的收集与整顿，初版算是整理出来了。心愿对大家有所帮忙。

JDK 是用于反对 Java 程序开发的最小环境。

Java 程序设计语言
Java 虚拟机
Java API 类库

JRE 是反对 Java 程序运行的规范环境。

Java SE API 子集
Java 虚拟机

引入泛型；
加强循环，能够应用迭代形式；
主动装箱与主动拆箱；
类型平安的枚举；
可变参数；
动态引入；
元数据（注解）；
引入 Instrumentation。

反对脚本语言；
引入 JDBC 4.0 API；
引入 Java Compiler API；
可插拔注解；
减少对 Native PKI(Public Key Infrastructure)、Java GSS(Generic Security Service)、Kerberos 和 LDAP(Lightweight Directory Access Protocol) 的反对；
继承 Web Services；
做了很多优化。

switch 语句块中容许以字符串作为分支条件；
在创立泛型对象时利用类型推断；
在一个语句块中捕捉多种异样；
反对动静语言；
反对 try-with-resources；
引入 Java NIO.2 开发包；
数值类型能够用 2 进制字符串示意，并且能够在字符串示意中增加下划线；
钻石型语法；
null 值的主动解决。

函数式接口
Lambda 表达式
Stream API
接口的加强
工夫日期加强 API
反复注解与类型注解
默认办法与静态方法
Optional 容器类

程序计数器
Java 虚拟机栈
本地办法栈
Java 堆
办法区
运行时常量池
间接内存

程序计数器（Program Counter Register）是一块较小的内存空间，能够看作是以后线程所执行字节码的行号指示器。分支、循环、跳转、异样解决、线程复原等根底性能都须要依赖这个计数器实现。

因为 Java 虚拟机的多线程是通过线程轮流切换并调配处理器执行工夫的形式实现的。为了线程切换后能复原到正确的执行地位，每条线程都须要一个独立的程序计数器，各线程之间的计数器互不影响，独立存储。

如果线程正在执行的是一个 Java 办法，计数器记录的是正在执行的虚拟机字节码指令的地址；
如果正在执行的是 Native 办法，这个计数器的值为空。

程序计数器是惟一一个没有规定任何 OutOfMemoryError 的区域。

Java 虚拟机栈（Java Virtual Machine Stacks）是线程公有的，生命周期与线程雷同。
虚拟机栈形容的是 Java 办法执行的内存模型：每个办法被执行的时候都会创立一个栈帧（Stack Frame），存储

局部变量表
操作栈
动静链接
办法进口

每一个办法被调用到执行实现的过程，就对应着一个栈帧在虚拟机栈中从入栈到出栈的过程。

这个区域有两种异常情况：

StackOverflowError：线程申请的栈深度大于虚拟机所容许的深度
OutOfMemoryError：虚拟机栈扩大到无奈申请足够的内存时

虚拟机栈为虚拟机执行 Java 办法（字节码）服务。

本地办法栈（Native Method Stacks）为虚拟机应用到的 Native 办法服务。

Java 堆（Java Heap）是 Java 虚拟机中内存最大的一块。Java 堆在虚拟机启动时创立，被所有线程共享。

作用：寄存对象实例。垃圾收集器次要治理的就是 Java 堆。Java 堆在物理上能够不间断，只有逻辑上间断即可。

办法区（Method Area）被所有线程共享，用于存储已被虚拟机加载的类信息、常量、动态变量、即时编译器编译后的代码等数据。

和 Java 堆一样，不须要间断的内存，能够抉择固定的大小，更能够抉择不实现垃圾收集。

运行时常量池（Runtime Constant Pool）是办法区的一部分。保留 Class 文件中的符号援用、翻译进去的间接援用。运行时常量池能够在运行期间将新的常量放入池中。

Object obj =  new  Object();

对于上述最简略的拜访，也会波及到 Java 栈、Java 堆、办法区这三个最重要内存区域。

Object obj

如果呈现在办法体中，则上述代码会反映到 Java 栈的本地变量表中，作为 reference 类型数据呈现。

new  Object()

反映到 Java 堆中，造成一块存储了 Object 类型所有对象实例数据值的内存。Java 堆中还蕴含对象类型数据的地址信息，这些类型数据存储在办法区中。

援用计数法
根搜索算法

给对象增加一个援用计数器，每当有一个中央援用它，计数器就 +1,；当援用生效时，计数器就 -1；任何时刻计数器都为 0 的对象就是不能再被应用的。

很难解决对象之间的循环援用问题。

通过一系列的名为“GC Roots”的对象作为起始点，从这些节点开始向下搜寻，搜寻所走过的门路称为援用链（Reference Chain），当一个对象到 GC Roots 没有任何援用链相连（用图论的话来说就是从 GC Roots 到这个对象不可达）时，则证实此对象是不可用的。

在 JDK 1.2 之后，Java 对援用的概念进行了裁减，将援用分为

强援用 Strong Reference
软援用 Soft Reference
弱援用 Weak Reference
虚援用 Phantom Reference

Object obj =  new  Object();

代码中普遍存在的，像上述的援用。只有强援用还在，垃圾收集器永远不会回收掉被援用的对象。

用来形容一些还有用，但并非必须的对象。软援用所关联的对象，有在零碎将要产生内存溢出异样之前，将会把这些对象列进回收范畴，并进行第二次回收。如果这次回收还是没有足够的内存，才会抛出内存异样。提供了 SoftReference 类实现软援用。

形容非必须的对象，强度比软援用更弱一些，被弱援用关联的对象，只能生存到下一次垃圾收集产生前。当垃圾收集器工作时，无论以后内存是否足够，都会回收掉只被弱援用关联的对象。提供了 WeakReference 类来实现弱援用。

一个对象是否有虚援用，齐全不会对其生存工夫够成影响，也无奈通过虚援用来获得一个对象实例。为一个对象关联虚援用的惟一目标，就是心愿在这个对象被收集器回收时，收到一个零碎告诉。提供了 PhantomReference 类来实现虚援用。

标记 - 革除算法
复制算法
标记 - 整顿算法
分代收集算法

分为标记和革除两个阶段。首先标记出所有须要回收的对象，在标记实现后对立回收被标记的对象。

效率问题：标记和革除过程的效率都不高。

空间问题：标记革除之后会产生大量不间断的内存碎片，空间碎片太多可能导致，程序调配较大对象时无奈找到足够的间断内存，不得不提前登程另一次垃圾收集动作。

将可用内存按容量划分为大小相等的两块，每次只应用其中一块。当这一块的内存用完了，就将存活着的对象复制到另一块下面，而后再把曾经应用过的内存空间一次清理掉。

复制算法使得每次都是针对其中的一块进行内存回收，内存调配时也不必思考内存碎片等简单状况，只有挪动堆顶指针，按程序分配内存即可，实现简略，运行高效。

将内存放大为原来的一半。在对象存活率较高时，须要执行较多的复制操作，效率会变低。

商业的虚拟机都采纳复制算法来回收新生代。因为新生代中的对象容易死亡，所以并不需要依照 1:1 的比例划分内存空间，而是将内存分为一块较大的 Eden 空间和两块较小的 Survivor 空间。每次应用 Eden 和其中的一块 Survivor。

当回收时，将 Eden 和 Survivor 中还存活的对象一次性拷贝到另外一块 Survivor 空间上，最初清理掉 Eden 和方才用过的 Survivor 空间。Hotspot 虚拟机默认 Eden 和 Survivor 的大小比例是 8:1，也就是每次新生代中可用内存空间为整个新生代容量的 90%（80% + 10%），只有 10% 的内存是会被“节约”的。

标记过程依然与“标记 - 革除”算法一样，但不是间接对可回收对象进行清理，而是让所有存活的对象向一端挪动，而后间接清理掉边界以外的内存。

依据对象的存活周期，将内存划分为几块。个别是把 Java 堆分为新生代和老年代，这样就能够依据各个年代的特点，采纳最适当的收集算法。

新生代：每次垃圾收集时会有少量对象死去，只有大量存活，所以抉择复制算法，只须要大量存活对象的复制老本就能够实现收集。
老年代：对象存活率高、没有额定空间对它进行调配担保，必须应用“标记 - 清理”或“标记 - 整顿”算法进行回收。

Minor GC：新生代 GC，指产生在新生代的垃圾收集动作，因为 Java 对象大多死亡频繁，所以 Minor GC 十分频繁，个别回收速度较快。
Full GC：老年代 GC，也叫 Major GC，速度个别比 Minor GC 慢 10 倍以上。

对于一个大型的零碎，当创立的对象及办法变量比拟多时，即堆内存中的对象比拟多，如果逐个剖析对象是否该回收，效率很低。分区是为了进行模块化治理，治理不同的对象及变量，以进步 JVM 的执行效率。

Young Generation Space 新生区（也称新生代）
Tenure Generation Space 养老区（也称旧生代）
Permanent Space 永恒存储区

对象优先调配在 Eden
大对象间接进入老年代
长期存活的对象将进入老年代
动静对象年龄断定
空间调配担保

次要用来存储新创建的对象，内存较小，垃圾回收频繁。这个区又分为三个区域：一个 Eden Space 和两个 Survivor Space。

当对象在堆创立时，将进入年老代的 Eden Space。
垃圾回收器进行垃圾回收时，扫描 Eden Space 和 A Suvivor Space，如果对象依然存活，则复制到 B Suvivor Space，如果 B Suvivor Space 曾经满，则复制 Old Gen
扫描 A Suvivor Space 时，如果对象曾经通过了几次的扫描依然存活，JVM 认为其为一个 Old 对象，则将其移到 Old Gen。
扫描结束后，JVM 将 Eden Space 和 A Suvivor Space 清空，而后替换 A 和 B 的角色（即下次垃圾回收时会扫描 Eden Space 和 B Suvivor Space。

Tenure Generation Space（采纳标记 - 整顿算法）

次要用来存储长时间被援用的对象。它外面寄存的是通过几次在 Young Generation Space 进行扫描判断过仍存活的对象，内存较大，垃圾回收频率较小。

存储不变的类定义、字节码和常量等。

Class 文件是一组以 8 位字节为根底单位的二进制流，各个数据我的项目间没有任何分隔符。当遇到 8 位字节以上空间的数据项时，则会依照高位在前的形式分隔成若干个 8 位字节进行存储。

每个 Class 文件的头 4 个字节称为魔数（Magic Number），它的惟一作用是用于确定这个文件是否为一个能被虚拟机承受的 Class 文件。OxCAFEBABE。

接下来是 Class 文件的版本号：第 5,6 字节是次版本号（Minor Version），第 7,8 字节是主版本号（Major Version）。

应用 JDK 1.7 编译输入 Class 文件，格局代码为：

前四个字节为魔数，次版本号是 0x0000，主版本号是 0x0033，阐明本文件是能够被 1.7 及以上版本的虚拟机执行的文件。

33：JDK1.7
32：JDK1.6
31：JDK1.5
30：JDK1.4
2F：JDK1.3

类加载器实现类的加载动作，同时用于确定一个类。对于任意一个类，都须要由加载它的类加载器和这个类自身一起确立其在 Java 虚拟机中的唯一性。即便两个类来源于同一个 Class 文件，只有加载它们的类加载器不同，这两个类就不相等。

启动类加载器（Bootstrap ClassLoader）：应用 C ++ 实现（仅限于 HotSpot），是虚拟机本身的一部分。负责将寄存在 \lib 目录中的类库加载到虚拟机中。其无奈被 Java 程序间接援用。
扩大类加载器（Extention ClassLoader）由 ExtClassLoader 实现，负责加载 \lib\ext 目录中的所有类库，开发者能够间接应用。
应用程序类加载器（Application ClassLoader）：由 APPClassLoader 实现。负责加载用户类门路（ClassPath）上所指定的类库。

双亲委派模型（Parents Delegation Model）要求除了顶层的启动类加载器外，其余加载器都该当有本人的父类加载器。类加载器之间的父子关系，通过组合关系复用。
工作过程：如果一个类加载器收到了类加载的申请，它首先不会本人去尝试加载这个类，而是把这个申请委派给父类加载器实现。每个档次的类加载器都是如此，因而所有的加载申请最终都应该传送到顶层的启动类加载器中，只有到父加载器反馈本人无奈实现这个加载申请（它的搜寻范畴没有找到所需的类）时，子加载器才会尝试本人去加载。

Java 类随着它的类加载器一起具备了一种带优先级的档次关系。比方 java.lang.Object，它寄存在 rt.jar 中，无论哪个类加载器要加载这个类，最终都是委派给启动类加载器进行加载，因而 Object 类在程序的各个类加载器环境中，都是同一个类。

如果没有应用双亲委派模型，让各个类加载器本人去加载，那么 Java 类型体系中最根底的行为也得不到保障，应用程序会变得一片凌乱。

Class 文件形容的各种信息，都须要加载到虚拟机后能力运行。虚拟机把形容类的数据从 Class 文件加载到内存，并对数据进行校验、转换解析和初始化，最终造成能够被虚拟机间接应用的 Java 类型，这就是虚拟机的类加载机制。

这两种机器都有代码执行的能力，然而：

物理机的执行引擎是间接建设在处理器、硬件、指令集和操作系统层面的。
虚拟机的执行引擎是本人实现的，因而能够自行制订指令集和执行引擎的构造体系，并且可能执行那些不被硬件间接反对的指令集格局。

栈帧是用于反对虚拟机进行办法调用和办法执行的数据结构，存储了办法的

局部变量表
操作数栈
动静连贯
办法返回地址

每一个办法从调用开始到执行实现的过程，就对应着一个栈帧在虚拟机栈外面从入栈到出栈的过程。

办法调用惟一的工作是确定被调用办法的版本（调用哪个办法），临时还不波及办法外部的具体运行过程。

Class 文件的编译过程不蕴含传统编译的连贯步骤，所有办法调用在 Class 文件外面存储的都只是符号援用，而不是办法在理论运行时内存布局中的入口地址。这使得 Java 有弱小的动静扩大能力，但使 Java 办法的调用过程变得绝对简单，须要在类加载期间甚至到运行时能力确定指标办法的间接援用。

invokestatic：调用静态方法
invokespecial：调用实例结构器办法、公有办法和父类办法
invokevirtual：调用所有的虚办法
invokeinterface：调用接口办法

解释执行（通过解释器执行）
编译执行（通过即时编译器产生本地代码）

当支流的虚拟机中都蕴含了即时编译器后，Class 文件中的代码到底会被解释执行还是编译执行，只有虚拟机本人能力精确判断。

Javac 编译器实现了程序代码通过词法剖析、语法分析到形象语法树，再遍历语法树生成线性的字节码指令流的过程。因为这一动作是在 Java 虚拟机之外进行的，而解释器在虚拟机的外部，所以 Java 程序的编译是半独立的实现。

Java 编译器输入的指令流，外面的指令大部分都是零地址指令，它们依赖操作数栈进行工作。

计算“1+1=2”，基于栈的指令集是这样的：

iconst_1
iconst_1
iadd
istore_0

两条 iconst_1 指令间断地把两个常量 1 压入栈中，iadd 指令把栈顶的两个值出栈相加，把后果放回栈顶，最初 istore_0 把栈顶的值放到局部变量表的第 0 个 Slot 中。

最典型的是 x86 的地址指令集，依赖寄存器工作。
计算“1+1=2”，基于寄存器的指令集是这样的：

mov eax,  1
add eax,  1

mov 指令把 EAX 寄存器的值设为 1，而后 add 指令再把这个值加 1，后果就保留在 EAX 寄存器里。

长处：

可移植性好：用户程序不会间接用到这些寄存器，由虚拟机自行决定把一些拜访最频繁的数据（程序计数器、栈顶缓存）放到寄存器以获取更好的性能。
代码绝对紧凑：字节码中每个字节就对应一条指令
编译器实现简略：不须要思考空间调配问题，所需空间都在栈上操作

毛病：

执行速度稍慢
实现雷同性能所需的指令纯熟多

频繁的拜访栈，意味着频繁的拜访内存，绝对于处理器，内存才是执行速度的瓶颈。

解析与填充符号表
插入式注解处理器的注解解决
剖析与字节码生成

Java 程序最后是通过解释器进行解释执行的，当虚拟机发现某个办法或代码块的运行特地频繁，就会把这些代码认定为“热点代码”（Hot Spot Code）。

为了进步热点代码的执行效率，在运行时，虚拟机将会把这些代码编译成与本地平台相干的机器码，并进行各种档次的优化，实现这个工作的编译器成为即时编译器（Just In Time Compiler，JIT 编译器）。

许多支流的商用虚拟机，都同时蕴含解释器和编译器。

当程序须要疾速启动和执行时，解释器首先发挥作用，省去编译的工夫，立刻执行。
当程序运行后，随着工夫的推移，编译器逐步发挥作用，把越来越多的代码编译成本地代码，能够进步执行效率。

如果内存资源限度较大（局部嵌入式零碎），能够应用解释执行节约内存，反之能够应用编译执行来晋升效率。同时编译器的代码还能退回成解释器的代码。

因为即时编译器编译本地代码须要占用程序运行工夫，要编译出优化水平更高的代码，所破费的工夫越长。

分层编译依据编译器编译、优化的规模和耗时，划分不同的编译档次，包含：

第 0 层：程序解释执行，解释器不开启性能监控性能，可登程第 1 层编译。
第 1 层：也成为 C1 编译，将字节码编译为本地代码，进行简略牢靠的优化，如有必要退出性能监控的逻辑。
第 2 层：也成为 C2 编译，也是将字节码编译为本地代码，然而会启用一些编译耗时较长的优化，甚至会依据性能监控信息进行一些不牢靠的激进优化。

用 Client Compiler 和 Server Compiler 将会同时工作。用 Client Compiler 获取更高的编译速度，用 Server Compiler 获取更好的编译品质。

被屡次调用的办法
被屡次执行的循环体

要晓得一段代码是不是热点代码，是不是须要触发即时编译，这个行为称为热点探测。次要有两种办法：

基于采样的热点探测，虚拟机周期性查看各个线程的栈顶，如果发现某个办法经常出现在栈顶，那这个办法就是“热点办法”。实现简略高效，然而很难准确确认一个办法的热度。
基于计数器的热点探测，虚构机会为每个办法建设计数器，统计办法的执行次数，如果执行次数超过肯定的阈值，就认为它是热点办法。

办法调用计数器
回边计数器（判断循环代码）

统计的是一个绝对的执行频率，即一段时间内办法被调用的次数。当超过肯定的工夫限度，如果办法的调用次数依然不足以让它提交给即时编译器编译，那这个办法的调用计数器就会被缩小一半，这个过程称为办法调用计数器的热度衰减，这个工夫就被称为半衰周期。

语言无关的经典优化技术之一：公共子表达式打消
语言相干的经典优化技术之一：数组范畴查看打消
最重要的优化技术之一：办法内联
最前沿的优化技术之一：逃逸剖析

广泛利用于各种编译器的经典优化技术，它的含意是：

如果一个表达式 E 曾经被计算过了，并且从先前的计算到当初 E 中所有变量的值都没有发生变化，那么 E 的这次呈现就成了公共子表达式。没有必要从新计算，间接用后果代替 E 就能够了。

因为 Java 会主动查看数组越界，每次数组元素的读写都带有一次隐含的条件断定操作，对于领有大量数组拜访的程序代码，这无疑是一种性能累赘。

如果数组拜访产生在循环之中，并且应用循环变量来进行数组拜访，如果编译器只有通过数据流剖析就能够断定循环变量的取值范畴永远在数组区间内，那么整个循环中就能够把数组的上下界查看打消掉，能够节俭很屡次的条件判断操作。

内联打消了办法调用的老本，还为其余优化伎俩建设良好的根底。

编译器在进行内联时，如果是非虚办法，那么间接内联。如果遇到虚办法，则会查问以后程序下是否有多个指标版本可供选择，如果查问后果只有一个版本，那么也能够内联，不过这种内联属于激进优化，须要预留一个逃生门（Guard 条件不成立时的 Slow Path），称为守护内联。

如果程序的后续执行过程中，虚拟机始终没有加载到会令这个办法的接受者的继承关系发现变动的类，那么内联优化的代码能够始终应用。否则须要摈弃掉曾经编译的代码，退回到解释状态执行，或者从新进行编译。

逃逸剖析的根本行为就是剖析对象动静作用域：当一个对象在办法外面被定义后，它可能被内部办法所援用，这种行为被称为办法逃逸。被内部线程拜访到，被称为线程逃逸。

栈上调配：个别对象都是调配在 Java 堆中的，对于各个线程都是共享和可见的，只有持有这个对象的援用，就能够拜访堆中存储的对象数据。然而垃圾回收和整顿都会耗时，如果一个对象不会逃逸出办法，能够让这个对象在栈上分配内存，对象所占用的内存空间就能够随着栈帧出栈而销毁。如果能应用栈上调配，那大量的对象会随着办法的完结而主动销毁，垃圾回收的压力会小很多。
同步打消：线程同步自身就是很耗时的过程。如果逃逸剖析能确定一个变量不会逃逸出线程，那这个变量的读写必定就不会有竞争，同步措施就能够打消掉。
标量替换：不创立这个对象，间接创立它的若干个被这个办法应用到的成员变量来替换。

即时编译器运行占用的是用户程序的运行工夫，具备很大的工夫压力。
Java 语言尽管没有 virtual 关键字，然而应用虚办法的频率远大于 C ++，所以即时编译器进行优化时难度要远远大于 C ++ 的动态优化编译器。
Java 语言是能够动静扩大的语言，运行时加载新的类可能改变程序类型的继承关系，使得全局的优化难以进行，因为编译器无奈看见程序的全貌，编译器不得不时刻留神并随着类型的变动，而在运行时撤销或从新进行一些优化。
Java 语言对象的内存调配是在堆上，只有办法的局部变量能力在栈上调配。C++ 的对象有多种内存调配形式。

运算工作，除了须要处理器计算之外，还须要与内存交互，如读取运算数据、存储运算后果等（不能仅靠寄存器来解决）。
计算机的存储设备和处理器的运算速度差了几个数量级，所以不得不退出一层读写速度尽可能靠近处理器运算速度的高速缓存（Cache），作为内存与处理器之间的缓冲：将运算须要的数据复制到缓存中，让运算疾速运行。当运算完结后再从缓存同步回内存，这样处理器就无需期待迟缓的内存读写了。
基于高速缓存的存储交互很好地解决了处理器与内存的速度矛盾，然而引入了一个新的问题：缓存一致性。在多处理器零碎中，每个处理器都有本人的高速缓存，它们又共享同一主内存。当多个处理器的运算工作都波及同一块主内存时，可能导致各自的缓存数据不统一。
为了解决一致性的问题，须要各个处理器拜访缓存时遵循缓存一致性协定。同时为了使得处理器充沛被利用，处理器可能会对输入代码进行乱序执行优化。Java 虚拟机的即时编译器也有相似的指令重排序优化。

Java 虚拟机的标准，用来屏蔽掉各种硬件和操作系统的内存拜访差别，以实现让 Java 程序在各个平台下都能达到统一的并发成果。

定义程序中各个变量的拜访规定，即在虚拟机中将变量存储到内存和从内存中取出这样的底层细节。此处的变量包含实例字段、动态字段和形成数组对象的元素，然而不包含局部变量和办法参数，因为这些是线程公有的，不会被共享，所以不存在竞争问题。

所以的变量都存储在主内存，每条线程还有本人的工作内存，保留了被该线程应用到的变量的主内存正本拷贝。线程对变量的所有操作（读取、赋值）都必须在工作内存中进行，不能间接读写主内存的变量。不同的线程之间也无奈间接拜访对方工作内存的变量，线程间变量值的传递须要通过主内存。

一个变量如何从主内存拷贝到工作内存、如何从工作内存同步回主内存，Java 内存模型定义了 8 种操作：

原子性：对根本数据类型的拜访和读写是具备原子性的。对于更大范畴的原子性保障，能够应用字节码指令 monitorenter 和 monitorexit 来隐式应用 lock 和 unlock 操作。这两个字节码指令反映到 Java 代码中就是同步块——synchronized 关键字。因而 synchronized 块之间的操作也具备原子性。
可见性：当一个线程批改了共享变量的值，其余线程可能立刻得悉这个批改。Java 内存模型是通过在变量批改后将新值同步回主内存，在变量读取之前从主内存刷新变量值来实现可见性的。volatile 的非凡规定保障了新值可能立刻同步到主内存，每次应用前立刻从主内存刷新。synchronized 和 final 也能实现可见性。final 润饰的字段在结构器中一旦被初始化实现，并且结构器没有把 this 的援用传递进来，那么其余线程中就能看见 final 字段的值。
有序性：Java 程序的有序性能够总结为一句话，如果在本线程内察看，所有的操作都是有序的（线程内体现为串行的语义）；如果在一个线程中察看另一个线程，所有的操作都是无序的（指令重排序和工作内存与主内存同步延迟线性）。

关键字 volatile 是 Java 虚拟机提供的最轻量级的同步机制。当一个变量被定义成 volatile 之后，具备两种个性：

保障此变量对所有线程的可见性。当一条线程批改了这个变量的值，新值对于其余线程是能够立刻得悉的。而一般变量做不到这一点。
禁止指令重排序优化。一般变量仅仅能保障在该办法执行过程中，失去正确后果，然而不保障程序代码的执行程序。

volatile 变量在各个线程的工作内存，不存在一致性问题（各个线程的工作内存中 volatile 变量，每次应用前都要刷新到主内存）。然而 Java 外面的运算并非原子操作，导致 volatile 变量的运算在并发下一样是不平安的。

在某些状况下，volatile 同步机制的性能要优于锁（synchronized 关键字），然而因为虚拟机对锁履行的许多打消和优化，所以并不是很快。

volatile 变量读操作的性能耗费与一般变量简直没有差异，然而写操作则可能慢一些，因为它须要在本地代码中插入许多内存屏障指令来保障处理器不产生乱序执行。

并发不肯定要依赖多线程，PHP 中有多过程并发。然而 Java 外面的并发是多线程的。

线程是比过程更轻量级的调度执行单位。线程能够把一个过程的资源分配和执行调度离开，各个线程既能够共享过程资源（内存地址、文件 I /O），又能够独立调度（线程是 CPU 调度的最根本单位）。

应用内核线程实现
应用用户线程实现
应用用户线程 + 轻量级过程混合实现

操作系统反对怎么的线程模型，在很大水平上就决定了 Java 虚拟机的线程是怎么映射的。

线程调度是零碎为线程调配处理器使用权的过程。

协同式线程调度：实现简略，没有线程同步的问题。然而线程执行工夫不可控，容易零碎解体。
抢占式线程调度：每个线程由零碎来调配执行工夫，不会有线程导致整个过程阻塞的问题。

尽管 Java 线程调度是零碎主动实现的，然而咱们能够倡议零碎给某些线程多调配点工夫——设置线程优先级。Java 语言有 10 个级别的线程优先级，优先级越高的线程，越容易被零碎抉择执行。

然而并不能齐全依附线程优先级。因为 Java 的线程是被映射到零碎的原生线程上，所以线程调度最终还是由操作系统说了算。如 Windows 中只有 7 种优先级，所以 Java 不得不呈现几个优先级雷同的状况。同时优先级可能会被零碎自行扭转。Windows 零碎中存在一个“优先级推进器”，当零碎发现一个线程执行特地怠惰，可能会越过线程优先级为它调配执行工夫。

当多个线程拜访一个对象时，如果不必思考这些线程在运行时环境下的调度和交替执行，也不须要进行额定的同步，或者在调用办法进行任何其余的协调操作，调用这个对象的行为都能够取得正确的后果，那这个对象就是线程平安的。

不可变
相对线程平安
绝对线程平安
线程兼容
线程对抗

在 Java 语言里，不可变的对象肯定是线程平安的，只有一个不可变的对象被正确构建进去，那其内部的可见状态永远也不会扭转，永远也不会在多个线程中处于不统一的状态。

虚拟机提供了同步和锁机制。

阻塞同步（互斥同步）
非阻塞同步

互斥是实现同步的一种伎俩，临界区、互斥量和信号量都是次要的互斥实现形式。Java 中最根本的同步伎俩就是 synchronized 关键字，其编译后会在同步块的前后别离造成 monitorenter 和 monitorexit 两个字节码指令。这两个字节码都须要一个 Reference 类型的参数指明要锁定和解锁的对象。如果 Java 程序中的 synchronized 明确指定了对象参数，那么这个对象就是 Reference；如果没有明确指定，那就依据 synchronized 润饰的是实例办法还是类办法，去获取对应的对象实例或 Class 对象作为锁对象。
在执行 monitorenter 指令时，首先要尝试获取对象的锁。

如果这个对象没有锁定，或者以后线程曾经领有了这个对象的锁，把锁的计数器 +1；当执行 monitorexit 指令时将锁计数器 -1。当计数器为 0 时，锁就被开释了。
如果获取对象失败了，那以后线程就要阻塞期待，晓得对象锁被另外一个线程开释为止。

除了 synchronized 之外，还能够应用 java.util.concurrent 包中的重入锁（ReentrantLock）来实现同步。ReentrantLock 比 synchronized 减少了高级性能：期待可中断、可实现偏心锁、锁能够绑定多个条件。

期待可中断：当持有锁的线程长期不开释锁的时候，正在期待的线程能够抉择放弃期待，对解决执行工夫十分长的同步块很有用。

偏心锁：多个线程在期待同一个锁时，必须依照申请锁的工夫程序来顺次取得锁。synchronized 中的锁是非偏心的。

互斥同步最大的问题，就是进行线程阻塞和唤醒所带来的性能问题，是一种乐观的并发策略。总是认为只有不去做正确的同步措施（加锁），那就必定会出问题，无论共享数据是否真的会呈现竞争，它都要进行加锁、用户态外围态转换、保护锁计数器和查看是否有被阻塞的线程须要被唤醒等操作。

随着硬件指令集的倒退，咱们能够应用基于冲突检测的乐观并发策略。先进行操作，如果没有其余线程征用数据，那操作就胜利了；如果共享数据有征用，产生了抵触，那就再进行其余的弥补措施。这种乐观的并发策略的许多实现不须要线程挂起，所以被称为非阻塞同步。

JDK1.6 的一个重要主题，就是高效并发。HotSpot 虚拟机开发团队在这个版本上，实现了各种锁优化：

适应性自旋
锁打消
锁粗化
轻量级锁
偏差锁

互斥同步对性能最大的影响是阻塞的实现，挂起线程和复原线程的操作都须要转入内核态中实现，这些操作给零碎的并发性带来很大压力。同时很多利用共享数据的锁定状态，只会继续很短的一段时间，为了这段时间去挂起和复原线程并不值得。先不挂起线程，等一会儿。

如果物理机器有一个以上的处理器，能让两个或以上的线程同时并行执行，让前面申请锁的线程稍等一会，但不放弃处理器的执行工夫，看看持有锁的线程是否很快就会开释。为了让线程期待，咱们只需让线程执行一个忙循环（自旋）。

自旋期待自身尽管防止了线程切换的开销，但它要占用处理器工夫。所以如果锁被占用的工夫很短，自旋期待的成果就十分好；如果工夫很长，那么自旋的线程只会白白耗费处理器的资源。所以自旋期待的工夫要有肯定的限度，如果自旋超过了限定的次数依然没有胜利取得锁，那就应该应用传统的形式挂起线程了。

自旋的工夫不固定了，而是由前一次在同一个锁上的自旋工夫及锁的拥有者的状态来决定。

如果一个锁对象，自旋期待刚刚胜利取得锁，并且持有锁的线程正在运行，那么虚拟机认为这次自旋依然可能胜利，进而运行自旋期待更长的工夫。
如果对于某个锁，自旋很少胜利，那在当前要获取这个锁，可能省略掉自旋过程，免得节约处理器资源。

有了自适应自旋，随着程序运行和性能监控信息的不断完善，虚拟机对程序锁的情况预测就会越来越精确，虚拟机也会越来越聪慧。

锁打消是指虚拟机即时编译器在运行时，对一些代码上要求同步，但被检测到不可能存在共享数据竞争的锁进行打消。次要依据逃逸剖析。

程序员怎么会在明晓得不存在数据竞争的状况下应用同步呢？很多不是程序员本人退出的。

原则上，同步块的作用范畴要尽量小。然而如果一系列的间断操作都对同一个对象重复加锁和解锁，甚至加锁操作在循环体内，频繁地进行互斥同步操作也会导致不必要的性能损耗。

锁粗化就是增大锁的作用域。

在没有多线程竞争的前提下，缩小传统的重量级锁应用操作系统互斥量产生的性能耗费。

打消数据在无竞争状况下的同步原语，进一步提高程序的运行性能。即在无竞争的状况下，把整个同步都打消掉。这个锁会偏差于第一个取得它的线程，如果在接下来的执行过程中，该锁没有被其余的线程获取，则持有偏差锁的线程将永远不须要同步。

参考：《深刻了解 Java 虚拟机：JVM 高级个性与最佳实际（第 2 版）》

如果感觉文章对你有点帮忙，请微信搜寻并关注「 冰河技术 」微信公众号，跟冰河学习高并发编程技术。

最初，附上并发编程须要把握的外围技能常识图，祝大家在学习并发编程时，少走弯路。

记住：你比他人强的中央，不是你做过多少年的 CRUD 工作，而是你比他人把握了更多深刻的技能。不要总停留在 CRUD 的外表工作，了解并把握底层原理并相熟源码实现，并造成本人的抽象思维能力，做到灵活运用，才是你冲破瓶颈，怀才不遇的重要方向！

你在刷抖音，玩游戏的时候，他人都在这里学习，成长，晋升，人与人最大的差距其实就是思维。你可能不信，优良的人，总是在一起。

写在后面

JDK 是什么？

JRE 是什么？

Java 历史版本的个性？

Java Version SE 5.0

Java Version SE 6

Java Version SE 7

Java 8

运行时数据区域包含哪些？

程序计数器（线程公有）

Java 虚拟机栈（线程公有）

本地办法栈（线程公有）

Java 堆（线程共享）

办法区（线程共享）

运行时常量池

Java 中对象拜访是如何进行的？

如何判断对象是否“死去”？

什么是援用计数法？

援用计数法的毛病？

什么是根搜索算法？

Java 的 4 种援用形式？

强援用

软援用

弱援用

虚援用

有哪些垃圾收集算法？

标记 - 革除算法（Mark-Sweep）

什么是标记 - 革除算法？

有什么毛病？

复制算法（Copying）- 新生代

长处

毛病

利用

标记 - 整顿算法（Mark-Compact）- 老年代

分代收集算法

Minor GC 和 Full GC 有什么区别？

Java 内存

为什么要将堆内存分区？

堆内存分为哪几块？

分代收集算法

内存调配有哪些准则？

Young Generation Space（采纳复制算法）

Permanent Space

Class 文件

Java 虚拟机的平台无关性

Class 文件的组成？

魔数与 Class 文件的版本

类加载器

类加载器的作用是什么？

类加载器有哪些？

类加载机制

什么是双亲委派模型？

为什么要应用双亲委派模型，组织类加载器之间的关系？

什么是类加载机制？

虚拟机和物理机的区别是什么？

运行时栈帧构造

Java 办法调用

什么是办法调用？

Java 的办法调用，有什么非凡之处？

Java 虚拟机调用字节码指令有哪些？

虚拟机是如何执行办法外面的字节码指令的？

解释执行

基于栈的指令集和基于寄存器的指令集

什么是基于栈的指令集？

什么是基于寄存器的指令集？

基于栈的指令集的优缺点？

Javac 编译过程分为哪些步骤？

什么是即时编译器？

解释器和编译器

为什么要采纳分层编译？

分层编译器有哪些档次？

编译对象与触发条件

热点代码有哪些？

如何判断一段代码是不是热点代码？

HotSpot 虚拟机应用第二种，有两个计数器：

办法调用计数器统计办法

有哪些经典的优化技术（即时编译器）？

公共子表达式打消

数组边界查看打消

办法内联