文章目录

3 运行时区域
- 3.1 本地方法栈
- 3.2 程序计数器
- 3.3 方法区
- - 3.3.1 Hotspot中方法区的演进
  - 3.3.2 设置方法区内存大小
  - 3.3.3 运行时常量池
  - 3.3.4 方法区使用举例
  - 3.3.5 方法区的演进
  - 3.3.5 方法区的垃圾回收
- 3.4 栈
- - 3.4.1 几个面试题
- 3.5 堆
- - 3.5.1 Minor GC、Major GC和Full GC
  - 3.5.2 使用分代思想的原因
  - 3.5.3 内存分配策略
  - 3.5.4 TLAB
  - 3.5.5 堆是不是分配对象存储的唯一选择
  - 3.5.5 堆调参
4 对象的实例化，内存布局和访问定位
- 4.1 对象的实例化
- - 4.1.1 对象创建的方式
  - 4.1.2 对象创建的步骤
- 4.2 对象的内存布局
- 4.3 对象的访问定位
5 直接内存
6 执行引擎
- 6.1 解释器和JIT编译器并存的原因
- 6.2 AOT编译器
7 StringTable
- 7.1 字符串拼接操作
- 7.2 intern方法
- 7.3 G1的String去重操作

3 运行时区域

3.1 本地方法栈

在这里插入图片描述

3.2 程序计数器

在这里插入图片描述
PC Register是唯一一个在Java虚拟机规范中没有规定任何OutOfMemoryError的区域。

为什么要有PC寄存器？
因为CPU会在不同的线程之间来回切换，切换回来之后，需要知道接着从哪里开始执行。
JVM字节码解释器需要通过改变PC寄存器中的值来明确下一条应该执行什么样的字节码指令。

PC寄存器为什么要设置成为线程私有？
为了能准确记录各个线程正在执行的字节码地址，最好的解决办法就是为每一个线程都分配一个PC寄存器。

3.3 方法区

在这里插入图片描述
独立于堆的一块内存空间。

方法区的大小决定了系统可以保存多少个类，如果系统定义了太多类，方法区溢出，虚拟机同样会抛出OutOfMemoryError。例如加载了大量的第三方的jar包；Tomcat部署的工程过多。大量的生成反射类。

存储类型信息，常量，静态变量，即时编译器编译后的代码缓存等。
【类型信息】
（1）这个类型的完整有效名称（全限定名 = 包名.类名）
（2）这个类型的直接父类的完整有效名称（interface或者java.lang.Object都没有父类）
（3）类型的修饰符（public，abstract，final的某个子集）
（4）类型直接接口的有序列表
【域信息】
（1）保存域的相关信息和声明顺序。
（2）域的相关信息包括：域名称，类型，修饰符（public private protected static final volatile transient的子集）等。
【方法信息】
（1）方法名，返回类型，按顺序的参数数量和类型，方法的修饰符
（2）方法的字节码，局部变量表的长度，异常表的静态信息。

【non-final类变量】
类变量被所有的实例共享，即使没有实例时也是可以访问的。

pubic class MethodAreaTest {
	public static void main(String[] args) {
		Order order = null;
		// 不会有空指针异常
		order.hello();
		System.out.println(order.count);
	}
}

class Order {
	public static int count = 1;
	public static void hello() {
		System.out.println("hello");
	}
}

3.3.1 Hotspot中方法区的演进

jdk7以前是永久代，使用的JVM中的内存
JDK8之后，使用元空间。元空间不在虚拟机设置的内存中，而是使用本地内存。

3.3.2 设置方法区内存大小

【java 7】
https://www.oracle.com/java/technologies/javase/vmoptions-jsp.html
https://docs.oracle.com/cd/E74363_01/ohi_vbp_-_installation_guide–20160224-094432-html-chunked/s66.html
https://docs.oracle.com/javase/7/docs/technotes/tools/windows/java.html

-XX:PermSize 设置永久代初始分配空间. 默认值是20.75M. (宋红康)

Option and default value	Description
-XX:MaxPermSize=64m	Size of the Permanent Generation. [5.0 and newer: 64 bit VMs are scaled 30% larger; 1.4 amd64: 96m; 1.3.1 -client: 32m.]。 64位机器默认是82M（宋红康）
【java 8】
https://docs.oracle.com/javase/8/docs/technotes/tools/windows/java.html
https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html

XX:MetaspaceSize=size
Sets the size of the allocated class metadata space that will trigger a garbage collection the first time it is exceeded. This threshold for a garbage collection is increased or decreased depending on the amount of metadata used. The default size depends on the platform.
windows下默认值是21M

-XX:MaxMetaspaceSize=size
默认不设限。 -1。设置案例 -XX:MaxMetaspaceSize=256m

3.3.3 运行时常量池

https://docs.oracle.com/javase/specs/jvms/se8/html/index.html

字节码文件中会包含常量池表。常量池表中包含各种字面量，类型、域和方法的符号引用。
运行时常量池是方法区的一部分。常量池在类加载之后就会放在运行时常量池中。运行时常量池具有动态性。

3.3.4 方法区使用举例

https://www.bilibili.com/video/BV1PJ411n7xZ?p=96&spm_id_from=pageDriver&vd_source=f4dcb991bbc4da0932ef216329aefb60

3.3.5 方法区的演进

HotSpot中方法区的变化：

Jdk 1.6之前	有永久代（permanent generation），静态变量存放在永久代上
jdk 1.7	有永久代，但是已经逐步“去永久代”，字符串常量池和静态变量等从永久代中移除，保存在堆中
jdk 1.8	无永久代，类型信息，字段，方法，常量保存在元空间（元空间是在本地内存），但是字符串常量池和静态变量仍然保存在堆中

【永久代被元空间替换的原因】
（1）永久代的空间大小比较难确定。
在像Web工程等项目中，动态加载的类很多，容易产生永久代的OOM。元空间不在虚拟机中，使用本地内存，元空间的大小仅受本地内存限制。
（2）永久代调优比较困难。
方法区垃圾收集主要回收两部分内容：常量池中废弃的常量和不再使用的类型。
如何判定一个类不再被使用是比较困难的。

【String Table被放在堆的原因】
永久代回收效率很低，在full gc的时候才会触发。但是开发过程中会有大量的字符串被创建，回收效率低会导致永久代内存不足。

【静态变量存在哪里】
静态引用的对象实体始终都在堆空间。 new 出来的对象实例肯定是在堆空间的。
JDK 7及其以后的版本的HotSport虚拟机选择把静态变量与类型在Java语言一段的映射Class对象存放在一起，存储于Java堆中。

3.3.5 方法区的垃圾回收

《Java虚拟机规范》中没有要求要对方法区进行GC。
ZGC就不支持类卸载

3.4 栈

栈管运行，堆管存储。

线程私有。生命周期和线程一致。

8种基本类型的变量 + 对象的引用变量 + 实例方法都是在函数的栈内存中分配。

一个栈帧就对应一个Java方法。

栈是一种快速有效的存储方式，访问速度仅次于程序计数器。栈不存在GC也不存在OOM问题。
在这里插入图片描述

Java虚拟机规范允许Java栈的大小是动态的或者是固定不变的。
如果采用固定大小的虚拟机栈，那么每一个线程的栈容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过了虚拟机栈允许的最大容量，Java虚拟机会抛出一个StackOverFlowError。
如果Java虚拟机栈可以动态扩展，并且在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的虚拟机栈，那么Java虚拟机会抛出OutOfMemoryError.

使用-Xss设置线程的最大栈空间。
在这里插入图片描述
不同线程中所包含的栈帧不允许存在相互引用，即不可能在一个栈帧之中应用另外一个线程的栈帧。
如果当前方法调用了其他方法，方法返回之际，当前栈帧会传回此方法的执行结果给前一个栈帧，接着，虚拟机会丢弃当前栈帧，使得前一个栈帧成为当前栈帧。
Java函数返回方式有两种：一种是正常的函数返回，例如使用了return指令；另外一种是抛出异常（这里是真正的抛出异常。如果异常被捕获处理，那就是正常函数返回。）。无论是哪种方式，都会导致栈帧被弹出。

【栈帧的内部结构】
1 局部变量表，Local Variables
局部变量表也被称为局部变量数组或者本地变量表。

定义为一个数字数组，主要用于存储方法参数和定义在方法体内的局部变量（包括基本数据类型，引用类型和returnAddress类型等）。

局部变量表为线程私有，不存在数据安全问题。

局部变量表所需的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间是不会改变局部变量表的大小的。

对一个函数而言，它的参数和局部变量越多，使得局变量表膨胀，它的栈帧就越大。

局部变量表中的变量只在当前方法调用中有效。在方法执行时，虚拟机通过使用局部变量表完成参数值到参数变量列表的传递过程。当方法调用结束之后，随着方法栈帧的销毁，局部变量表也会随之销毁。

局部变量表最基本的存储单元是Slot（变量槽）。在局部变量表里，32位以内的类型只占用一个slot（包括returnAddress类型），64位类型（long和double）需要占用两个slot。byte、short、char在存储之前会被转换为int；boolean类型也会被转换为int，0表示false，非0表示true。

如果需要访问局部变量表中一个64bit的局部变量（long或者double）值时，只需要使用前一个索引（64位的占两个slot）即可。

如果当前帧是由构造方法或者实例方法创建的，那么该对象的this引用会被放在index为0的slot处，其余的参数按照参数列表的顺序继续排列。

Slot是可以重复利用的.

public void test4() {
	int a = 0;
	{
		int b = 0;
		b = a + 1;
	}
	// 局部变量表的长度就是3
	// 变量c使用之前已经销毁的变量b的slot
	int c = a + 1;
}

index  Name
2     b 
0     this
1     a
2     c

【静态变量和局部变量对比】
变量的分类
按照数据类型分：① 基本数据类型 ② 引用数据类型
按照在类中声明的位置分： ① 成员变量：在使用前都经历过默认的初始化过程
<1> 类变量：linking的prepare阶段，给类变量赋默认初始值；initial阶段：执行静态代码块中的语句，赋值。
<2> 实例变量：随着对象的创建，会在堆空间中分配实例变量空间，并进行默认赋值。
② 局部变量：在使用前，必须要进行显式的赋值。否则编译不通过。

public void test5Temp() {
	int num;
	// 直接编译报错：Variable 'num' might not have been initialized.
	System.out.println(num);
}

在栈帧中，与性能调优关系最密切的部分就是局部变量表。在方法执行时，虚拟机使用局部变量表完成方法的传递。
局部变量表中的变量是重要的垃圾回收的根节点，只要被局部变量表中直接或者间接引用的对象都不会被回收。

2 操作数栈， Operand stack，或者称为表达式栈

操作数栈，在方法执行过程中，根据字节码指令，向栈中写入数据或者从栈中提取数据。
例如

[8]                                                                        [23]
[15]           -----------add 操作执行之后--------->                         [其他元素]
[其他元素]

如果被调用的方法有返回值，其返回值会被压入当前栈帧的操作数栈中，并更新pc寄存器中下一条需要执行的指令的偏移地址。
操作数栈中元素的数据类型必须与字节码指令的序列严格匹配。这由编译器在编译期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段会再次验证。
Java虚拟机的解释器是基于栈的执行引擎，这里的栈就是操作数栈。

操作数栈主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间。操作数栈就是执行引擎的一个工作区，当一个方法开始执行的时候，会创建新的栈帧，操作数栈也是空的。操作数栈的深度在编译期间就一定确定，保存在Code属性的max_stack中。32位长度的类型占用一个栈深度，64位的占用两个。操作数栈并不能通过数组索引方式访问，只能通过入栈和出栈操作来完成数据访问。

【栈顶缓存技术】
基于栈式架构的虚拟机使用的零地址指令更加紧凑，但是完成一项操作的时候必然要使用更多的入栈和出栈指令，这时就意味着将需要更多的指令分派次数（instruction dispatch）和内存读写次数。

由于操作数是存储在内存中的，因此频繁的内存读写必然会影响执行速度。为了解决此问题，HotSpot JVM设计者们提出了栈顶缓存（ToS， Top-of-Stack Cashing）技术，将栈顶元素全部缓存在物理CPU的寄存器中，为此降低了对内存的读写次数，提升执行引擎的执行效率。

3 动态链接，Dynamic linking，或者称为指向运行时常量池的方法引用
每一个栈帧内部都包含一个指向运行时常量池中该帧所属方法的引用。包含这个应用的目的就是为了支持当前方法能够实现动态链接。比如：invokedynamic指令

在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic Reference）保存在class文件的常量池中。例如：描述一个方法调用了另外的其他方法时，就是通过常量池中指向方法的符号引用来表示的，那么动态链接的作用就是将这些符号引用转换为调用方法的直接引用。

为什么需要常量池？
常量池的作用就是提供一些符合和常量，便于指令识别。

【方法的调用】
静态链接：当一个字节码文件被装载到JVM内部时，如果被调用的目标方法在编译期可知，且运行期保持不变。这种情况下调用方法的符号引用转为直接引用的过程称为静态连接。
动态链接：如果被调用方法在编译期无法确定下来，换言之，只能在程序运行期将调用方法的符号引用转换为直接引用，这种引用转换过程具有动态性，因此也被称为动态链接。

绑定：绑定是一个字段、方法或者类在符号引用被替换为直接引用的过程，这个过程仅仅发生一次。
早期绑定：静态链接，目标方法在编译期可知，并且运行期间保持不变，可以直接静态连接。
晚期绑定：动态链接。

C语言这种面向过程的只有早期绑定。面向对象的语言，具有多态性，具备早期绑定和晚期绑定两种绑定方式。

非虚方法：编译期就确定了调用版本，并且运行时不可变。此种就称为非虚方法。
非非虚方法就是虚方法。

普通调用指令
invokestatic：调用静态方法，解析阶段确定唯一方法版本。
invokespecial：调用方法、私有及父类方法，解析阶段确定唯一方法版本。
invokevirtual：调用所有的虚方法，也会调用final修饰的方法，但是final修饰的方法不是虚方法
invokeinterface：调用接口方法。
动态调用指令
invokedynamic：动态解析出需要调用的方法，然后执行。

前四条指令固化在虚拟机内部，方法的调用执行完全不可人为干预。invokedynamic指令支持用于确定方法版本。

静态类型语言：对类型的检查在编译期。判断变量自身的类型信息。
动态类型语言：对类型的检查在运行期。判断变量值的类型信息，变量没有类型信息。

【Java语言中方法覆写的本质】
（1）找到操作数栈顶的第一个元素所执行的对象的实际类型，记为C
（2）如果在类型C中找到与常量中描述符合并且简单名称都相符的方法，则进行访问权限校验，如果通过则返回这个方法的直接引用，查找过程结束；如果不通过，则返回java.lang.IllegalAccessError
（3）否则，按照继承关系从下往上依次对C的各个父类进行第（2）步的搜索和验证过程
（4）如果始终没有找到合适的方法，则抛出java.lang.AbstractMethodError

java.lang.IllegalAccessError介绍：程序试图访问或修改一个属性，或者程序试图调用一个方法，但是程序没有对这个属性或者方法的访问权限。一般这种情况就会引起编译器异常。如果这个错误发生在运行时，就说明一个类发生了不兼容的改变。

为了提高性能，JVM在类的方法区建立虚方法表（virtual method table）。使用索引表来代替查找。每个类中都有虚方法表，表中存放各个方法的实际入口。虚方法表会在类加载过程中的链接阶段（Resolving阶段）被创建并初始化，类的变量初始值准备完成之后，JVM会把该类的方法表也初始化完毕。

4 方法返回地址，Return Address，或者称为方法正常异常退出的定义
存放调用该方法的PC寄存器的值

正常退出保存的是PC寄存器的值，异常退出就不保存了。异常退出的返回地址要根据异常表来确定，栈帧中不会保存这部分信息。

ireturn：返回值是boolean，byte，char，short或者int
lreturn：long
freturn： float
dreturn： double
areturn：引用类型
return：没有返回值的，void方法，构造方法，静态代码块等。

5 附加信息
例如，对程序调试提供支持的信息。

3.4.1 几个面试题

【栈溢出】
StackOverFlowError

在这里插入图片描述

3.5 堆

Java虚拟机规范规定，堆可以处于物理上不连续的内存空间中，但是在逻辑上应该是连续的。

堆空间中可以专门划分线程私有缓冲区（Thread Local Allocation Buffer，TLAB）。

在这里插入图片描述
java 8 以及以后逻辑上分为三部分：新生代+老年代+元空间（方法区）。

-Xms ：堆（年轻代+年老带）的起始大小，ms是memory start
-Xmx：堆的最大大小
默认情况下，初始堆大小是物理内存 / 64；最大内存是物理内存 / 4;

查看设置的参数：
方式一：jps / jstat -gc 进程id
方式二：-XX:+PrintGcDetails

Eden满了就会触发YGC（又被称为MinorGC），会回收Eden区和Survivor区中的对象。

幸存者区s0, s1区的运行规则：复制之后有交换，空的就是to区。
在这里插入图片描述

垃圾回收：频繁在新生区收集，很少在老年代收集，几乎不再永久代/元空间收集。

3.5.1 Minor GC、Major GC和Full GC

GC按照回收区域分为部分收集（Partical GC）和整体收集（Full GC）。
部分收集分为：（1）新生代收集：Minor GC / Young GC, 只是新生代的垃圾收集。触发条件：Eden区满的时候。Minor GC会引发STW，暂停其他用户的线程，等垃圾回收结束，用户线程才会恢复运行。（2）老年代收集：Major GC / Old GC, 只是老年代的垃圾收集。目前，只有CMS GC会有单独收集老年代的行为。注意很多时候Major GC和Full GC混淆使用，需要具体分辨是老年代回收还是整体回收。触发条件：老年代空间不足的时候，会先尝试触发minor gc。如果minor gc之后空间还是不足的，则会触发Major gc。（3）混合收集：Mixed GC，收集整个新生代以及部分老年代的垃圾收集。目前，只有G1 GC会有这种行为。

整堆收集：Full GC，收集整个Java堆和方法区。
Full GC执行的情况有：（1）调用System.gc()时，系统建议执行Full GC,但是不是必然执行。（2）老年代空间不足。（3）方法区空间不足。（4）通过Minor GC后进入老年代的平均大小大于老年代的可用内存。（5）向to区复制时，对象大小大于to区可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小。

3.5.2 使用分代思想的原因

不分代也可以，分代的唯一理由就是GC性能优化。

3.5.3 内存分配策略

优先分配到Eden
大对象直接分配到老年代。
程序中应该尽量避免出现过多的大对象。
长期存活的对象分配到老年代。
动态对象年龄判断
如果Survivor区中相同年龄的所有对象的大小总和大于Survivor空间的一半，年龄大于或者等于改年龄的对象可以直接进入老年代，无需等到MaxTenuringTreshold中要求的年龄。
空间分配担保
-XX：HandlePromotionFailure

3.5.4 TLAB

对Eden区进行划分，为每一个线程分配一个私有的缓存区域。
JVM将TLAB作为内存分配的首选。
默认情况下，TLAB空间非常小，仅有Eden空间的1% 。

3.5.5 堆是不是分配对象存储的唯一选择

【栈上分配】

如果经过逃逸分析后发现，一个对象并没有逃逸出方法的话那么就可以被优化成栈上分配。

【同步省略】

逃逸分析会进行锁消除优化。

public void f() {
	Object hollis = new Object();
	synchronized (hollis) {
		System.out.println(hollis);
	}
}

=====优化后=======
public void f() {
	Object hollis = new Object();
	System.out.println(hollis);
}

【标量替换】

标量是指无法再分解成更小数据的数据。Java中的原始数据类型就是标量。相对的，哪些还可以分解的数据叫做聚合量。 Java中的对象就是聚合量。
在JIT阶段，如果经过逃逸分析发现一个对象不会被外界访问的话，那么经过jit优化，就会把这个对象拆解成若干个标量来进行替代。这就是标量替换。

【元数据区】
逃逸分析并不成熟。逃逸分析本身也是需要极大的性能消耗，不能保证逃逸分析能带来收益。

intern字符串缓存和静态变量并不是在元数据区，而是直接在堆上分配的。

所以，对象基本上都是分配在堆上的。

3.5.5 堆调参

在这里插入图片描述

4 对象的实例化，内存布局和访问定位

4.1 对象的实例化

4.1.1 对象创建的方式

new
变形1：XXX的静态方法，例如单例模式的getInstance
变形2：xxxBuilder/xxxFactory的静态方法
反射
Class.newInstance：只能调用空参的构造器，权限也必须是public
Constructor.newInstance：可以调用无参的或者带参的构造器，权限没有要求。
使用clone
需要实现clone方法
使用反序列化
三方库Objenesis

4.1.2 对象创建的步骤

【1 判断对应的类是否加载、连接和初始化】
【2 为对象分配内存】
如果内存是规整的，使用指针碰撞。
如果内存不规整，通过空闲列表方式进行内存分配。
【3 处理并发安全问题】
采用CAS失败重试，区域加锁等保证更新的原子性。
TLAB
【4 初始化分配到的空间】
所有属性设置默认值，保证对象实例在不赋值时可以直接使用
【5 设置对象的对象头】

【6 显式的初始化】
init 和 clinit

4.2 对象的内存布局

【对象头】

运行时元数据（Mark Word）
hash code
GC分代年龄
锁状态标志
线程持有的锁
偏向线程id
偏向时间戳
类型指针
指向Class对象

如果是数组的话，还会记录数组的长度。
【实例数据】
父类中定义的变量在子类的变量之前
相同宽度的字段总是被分配在一起
如果CompactFields参数为true（默认为true）：子类的窄变量可能插入到父类变量的空隙中。
【对齐填充】

4.3 对象的访问定位

句柄访问
好处：对象移动的时候只需要修改句柄的指向就可以了。
缺点：需要专门为句柄池开辟内存，两级引用，访问效率比较低。
直接指针
HotSpot采用的就是直接指针。
优点：
缺点：

5 直接内存

IO	NIO （New IO / Non-Blockinh IO）
byte[] / char[]	Buffer
Stream	Channel

// 直接分配本地内存空间
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(1024 * 1024 * 1024)

直接内存既不是运行时数据区的一部分，也不是《Java虚拟机规范》中定义的内存区域。是是在Java堆外的，直接向系统申请的内存空间。
来源于NIO，通过存在堆中的DirectByteBuffer操作native内存。
通常访问直接内存的速度优于Java堆，读写性能高。
存在OOM的情况
可以通过MaxDirectMemorySize设置直接内存的大小，默认和-Xmx 的参数值一致。

6 执行引擎

6.1 解释器和JIT编译器并存的原因

JIT：速度快
解释器：程序启动后，解释器可以马上发挥作用，省掉编译的时间，立即执行。

【方法调用计数器】
统计方法的调用次数。Client模式下默认阈值是1500次，Server模式下是10000次。阈值可以通过-XX:CompileThreshold设定。

计数器统计的是相对的执行频率（一段时间内的方法被调用的次数）。当超过一定的时间限度，方法的调用次数仍然没有达到阈值，那么计数就会减半，这个过程就称为计数器热度衰减（Counter Decay）。这段时间就称为半衰周期（Counter Half life time）。

-XX:-UseCounterDecay:关闭热度衰减
-XX:-CounterHalfLifeTime: 半衰周期，单位s。
【回边计数器】
统计循环体中代码执行的次数。
在字节码中遇到控制流向后跳转的指令称为“回边（Back Edge）”。

-Xint：完全采用解释器执行
-Xcomp：完全采用即时编译器执行程序。如果即时编译器出现问题，解释器会介入执行。
-Xmixed：采用解释器+即时编译器的混合模式共同执行。

HotSpot VM中有两个JIT编译器，分别是Client Compiler和Server Compiler。简称C1和C2编译器。
-client：C1编译器。 C1编译器对字节码进行简单和可靠的优化，耗时短。具有更快的编译速度。
方法内联：将引用的函数代码编译到引用点处，减少栈帧的生成，减少参数传递和跳转过程。
去虚拟化：对唯一的实现类进行内联。
荣誉消除：在运行期间把一些不会执行到的代码折叠掉。
-server：C2编译器。 C2编译器进行较长的激进的优化。优化的代码效率更高。
标量替换
栈上分配
同步消除。

分层编译策略：程序解释执行的时候可以触发C1编译，将字节码编译成机器码的时候进行简单优化。如果加上性能监控，C2编译器会根据性能监控信息进行激进优化。
java7之后，只要是-server模式，默认会开启分层编译策略。

6.2 AOT编译器

静态提前编译器，Ahead of Time Compiler。AOT编译器在程序运行之前，便将字节码转换为机器码。

7 StringTable

java8中String的数据结构是char[], jdk 9中变成了byte[].
改变的motivation：经统计，字符串中大部分都是拉丁字母，如果使用char数组存储有点浪费空间。
Java 9的String中增加了字符串编码标记（encoding-flag）。

字符串常量池中不会存储相同内容的字符串。

String Pool是一个固定大小的HashTable，默认长度是1009（jdk 6中的默认值）. 在jdk 7中，StringTable的长度默认值为60013（可以设置长度，没有要求）, JDK 8开始， 1009是可以设置的最小值。

7.1 字符串拼接操作

常量和常量的拼接结果在常量池，原理是编译期优化。

public void test1() {
	String s1 = "a" + "b" + "c";
	String s2 = "abc";

	System.out.println(s1 == s2); // true
	System.out.println(s1.equals("s2")); // true 
}

常量池中不会存在相同内容的常量
只要有一个是变量，结果就在堆中。变量拼接的原理是StringBuilder

public void test2() {
	String s1 = "javaEE";
	String s2 = "hadoop";
	String s3 = "javaEEhadoop";
	String s4 = "javaEE" + "hadoop";
	String s5 = s1 + "hadoop";
	String s6 = "javaEE" + s2;
	/**
	* 执行细节：
	* ① builder = new StringBuilder();
	* ② builder.append(s1)
	* ③ builder.append(s2)
	* ④ builder.toString(); 约等于new String
	*  
	* jdk 5.0和之后使用的是StringBuilder，5.0之前使用的StringBuffer
	**/
	String s7 = s1 + s2;

	System.out.println(s3 == s4); // true
	System.out.println(s3 == s5); // false
	System.out.println(s3 == s6); // false
	System.out.println(s3 == s7); // false
	System.out.println(s5 == s6); // false	
	System.out.println(s5 == s7); // false
	System.out.println(s6 == s7); // false	
	
	String s8 = s6.intern();
	System.out.println(s3 == s8); // true
}

public void test4() {
	final String s1 = "a";
	final String s2 = "b";
	String s3 = "ab";
	String s4 = s1 + s2; // 因为有final修饰，这里是“常量”
	System.out.println(s3 == s4); // true
}

如果拼接的结果调用intern 方法，则主动将常量池中还没有的字符串放入池中，并返回此对象的地址。

7.2 intern方法

【new String(“ab”)会创建几个对象？】
两个，new出来的一个，字符串常量池中的"ab"是另一个。

使用jclasslib查看编译出来的字节码文件可以知道。

【String str = new String(“a”) + new String(“b”) 会创建几个对象？】
对象1：new StringBuilder
对象2： new String(“a”)
对象3：常量池中的"a"
对象4： new String(“b”)
对象5：常量池中的"b"
对象6：StringBuilder中的toString()会new String（“ab”），但是字符串常量池中是没有“ab”的

        // new 出来的对象
        String s = new String("1");
        // 没有作用，常量池中已经有“1”了。
        s.intern();
        // 指向常量池中的string
        String s2 = "1";
        // jdk 6/7/8以及之后，都是false
        System.out.println(s == s2);

        // s3 变量的地址就是new String("11")
        String s3 = new String("1") + new String("1");
        // "11"加入到了常量池中
        // jdk 6: 创建了一个新的对象“11”，放到常量池中
        // jdk 7/8和以后：常量池中记录了堆里面的“11”的地址，没有创建新的。
        s3.intern();
        // s4就是常量池中“11”的地址
        String s4 = "11";
        System.out.println(s3 == s4);

		// s3 变量的地址就是new String("11")
        String s3 = new String("1") + new String("1");
        // 字符串常量池中创建新的。 
        String s4 = "11";
        String s5 = s3.intern();
        System.out.println(s3 == s4); // false
        System.out.println(s5 == s4); // true

 		// s = new String("ab")
        String s = new String("a") + new String("b");
        // jdk 6 : s2 != s
        // jdk 17 : s2 == s.
        String s2 = s.intern();
        System.out.println(s2 == "ab"); // jdk 6: true.    jdk 17: true
        System.out.println(s == "ab");  // jdk 6: false.   jdk 17: true

        String x = "ab";
        // s = new String("ab")
        String s = new String("a") + new String("b");
        String s2 = s.intern();
        System.out.println(s2 == "ab"); // true
        System.out.println(s == "ab"); // false

        String s1 = new String("a") + new String("b");
        // 常量池中的字串引用指向s1
        s1.intern();
        // 常量池中的字串
        String s2 = "ab";
        System.out.println(s1 == s2); // open jdk 17:true

        // s1是new出来的
        String s1 = new String("ab");
        // 没有作用，常量池中已经有ab了。
        s1.intern();
        String s2 = "ab";
        System.out.println(s1 == s2); // open jdk 17:false