前言

上一篇主要从整体架构上概括了Java的内存结构，只是在宏观上有一个大体的认识，不够深入，接下来这篇文章，将进一步深入探究Java的内存结构模型，作为上一篇的补充。

正文

接下来，结合两个示例代码来深入探究Java 的内存结构，
示例代码1：

/*** VM参数* -Xms30m                     设置堆内存最小值为30M* -Xmx30m                     设置堆内存最大值为30M* -XX:MaxMetaspaceSize=30m    设置元空间最大值为30M* -XX:+UseConcMarkSweepGC     启用CMS垃圾收集器* -XX:-UseCompressedOops      禁用压缩指针的使用*/
public class JVMObject {public final static String MAN_TYPE = "man"; // 常量public static String WOMAN_TYPE = "woman";  // 静态变量public static void  main(String[] args)throws Exception {Teacher T1 = new Teacher();T1.setName("Mark");T1.setSexType(MAN_TYPE);T1.setAge(36);for(int i =0 ;i<15 ;i++){System.gc();//主动触发GC 垃圾回收 15次--- T1存活}Teacher T2 = new Teacher();T2.setName("King");T2.setSexType(MAN_TYPE);T2.setAge(18);Thread.sleep(Integer.MAX_VALUE);//线程休眠}
}class Teacher{String name;String sexType;int age;public String getName() {return name;}public void setName(String name) {this.name = name;}public String getSexType() {return sexType;}public void setSexType(String sexType) {this.sexType = sexType;}public int getAge() {return age;}public void setAge(int age) {this.age = age;}
}

示例代码2：

public class JVMStack {public int work(int x) throws Exception{int z =(x+5)*10;//局部变量表有， 32位Thread.sleep(Integer.MAX_VALUE);return  z;}public static void main(String[] args)throws Exception {JVMStack jvmStack = new JVMStack();jvmStack.work(10);//10  放入main栈帧  10 ->操作数栈}
}

一、JVM的运行流程

加入VM参数

 -Xms30m -Xmx30m  -XX:MaxMetaspaceSize=30m  -XX:+UseConcMarkSweepGC -XX:-UseCompressedOops

启动示例代码1

上述代码的执行过程中，JVM具体做了哪些工作呢？
1. JVM 向操作系统申请内存
JVM 第一步就是通过配置参数或者默认配置参数向操作系统申请内存空间，操作系统根据内存大小找到具体的内存分配表，然后把内存段的起始地址和终止地址分配给 JVM，接下来 JVM 就进行内部分配。
2. 初始化运行时数据区
JVM 获得内存空间后，会根据配置参数分配堆、栈以及方法区的内存大小
-Xms30m -Xmx30m -Xss1m -XX:MaxMetaspaceSize=30m

3. 类加载（类加载的细节后续章节会详细讲）
这里主要是把 class 放入方法区、还有 class 中的静态变量和常量也要放入方法区

4. 执行方法及创建对象
启动 main 线程，执行 main 方法，开始执行第一行代码。此时堆内存中会创建一个 Teacher对象，对象引用 T1 就存放在栈中。后续代码中遇到 new 关键字，会再创建一个 Teacher对象，对象引用T2 就存放在栈中。

小结

JVM 在操作系统上启动，申请内存，先进行运行时数据区的初始化，然后把类加载到方法区，最后执行方法。方法的执行和退出过程在内存上的体现就是虚拟机栈中栈帧的入栈和出栈。同时在方法的执行过程中创建的对象一般情况下都是放在堆中，最后堆中的对象也是需要进行垃圾回收清理的。

二、从底层深入理解运行时数据区

1、堆空间分代划分

堆被划分为新生代和老年代（Tenured），新生代又被进一步划分为 Eden 和 Survivor 区，最后 Survivor 由 From Survivor 和 To Survivor 组成。（先有个概念，后续对象分配和垃圾回收会细讲这块）

GC概念

GC- Garbage Collection 垃圾回收，在 JVM 中是自动化的垃圾回收机制，我们一般不用去关注，在 JVM 中 GC 的主要区域是堆空间。
我们也可以通过一些额外方式主动发起它，比如 System.gc(),主动发起。（项目中切记不要使用，严重影响性能）

2、JHSDB ——内存可视化工具

JHSDB 是一款基于服务性代理实现的进程外调试工具。服务性代理是 HotSpot 虚拟机中一组用于映射 Java 虚拟机运行信息的，主要基于 Java 语言实现的API 集合。

2.1 JHSDB的开启方式

• JDK1.8 中的开启方式
  （1）首先需将 sawindbg.dll（一般会在 JDK自带的jre 目录下）复制到安装的jre 的对应目录中 (注意在 win 上安装了 JDK1.8 后往往同级目录下有一个jre 的目录)
  
  （2）然后到目录：D:\Java\jdk1.8.0_112\lib 进入命令行，执行 java -cp .\sa-jdi.jar sun.jvm.hotspot.HSDB
  
• JDK1.9 及以后的开启方式
  进入 JDK 的 bin 目录下，我们可以在命令行中使用 jhsdb hsdb 来启动它

2.2 JHSDB中查看堆信息

1. 启动示例代码1
   
2. 因为 JVM 启动有一个进程，需要借助一个命令 jps 查找到对应程序的进程
   
3. 在JHSDB中依次点击File->Attach to HotSpot process，在弹出的界面中输入要查看的类的进程ID
   
   
4. 查看堆参数
   
   图中显示了实际 JVM 启动过程中堆中参数的对照，可以看到，在不启动内存压缩的情况下。堆空间里面的分代划分都是连续的。
5. 查看堆中对象
   
   这里可以看到 JVM 中所有的对象，都是基于 class 的对象，可以在这里进行全路劲名搜索自己想查看的对象。
   
   最后再对比一下内存地址可以得出 T1 在老年代，T2 在 Eden，如图所示
   
   

2.3 JHSDB中查看栈信息

• 选中要查看的线程 ，点击 Stack Memory 按钮
  
  
  从上图中可以验证栈内存，同时也可以验证到虚拟机栈和本地方法栈在 Hotspot 中是合二为一的实现了。

3、小结

深入辨析堆和栈

• 功能
  栈内存以栈帧的方式存储方法调用的过程，并存储方法调用过程中基本数据类型的变量（int、short、long、byte、float、double、boolean、char 等）以及对象的引用变量，其内存分配在栈上，变量出了作用域就会自动释放；
  堆内存用来存储 Java 中的对象。无论是成员变量，局部变量，还是类变量，它们指向的对象都存储在堆内存中；
• 线程独享还是共享
  栈内存归属于单个线程，每个线程都会有一个栈内存，其存储的变量只能在其所属线程中可见，即栈内存可以理解成线程的私有内存。
  堆内存中的对象对所有线程可见。堆内存中的对象可以被所有线程访问。
• 空间大小
  栈的内存要远远小于堆内存

三、虚拟机栈的优化技术——栈帧之间的数据共享

在一般的模型中，两个不同的栈帧的内存区域是独立的，但是大部分的 JVM 在实现中会进行一些优化，使得两个栈帧出现一部分重叠。（主要体现在方法中有参数传递的情况），让下面栈帧的操作数栈和上面栈帧的部分局部变量重叠在一起，这样做不但节约了一部分空间，更加重要的是在进行方法调用时就可以直接公用一部分数据，无需进行额外的参数复制传递了。

下面通过JHSDB来查看栈帧之间的数据共享

• 运行示例代码2
  
• 在JHSDB查看栈信息
  

public class JVMStack {public int work(int x) throws Exception{int z =(x+5)*10;//局部变量表有， 32位Thread.sleep(Integer.MAX_VALUE);return  z;}public static void main(String[] args)throws Exception {JVMStack jvmStack = new JVMStack();jvmStack.work(10);//10  放入main栈帧  10 ->操作数栈}

• 代码分析
  栈帧之间的数据共享，就是物理上的同一块内存区域，在JVM的逻辑中被虚拟成两块或更多块的内存区域，比如main方法中的work(10)中的 10 在jvm中是存放在main方法栈帧的操作数栈，而work(int x)中的 x 在jvm中是存放在work方法栈帧的局部变量表，但他们的真实内存地址是同一块，因此 x==10,从而实现了栈帧之间的数据共享

四、内存溢出

1、栈溢出

HotSpot 版本中栈的大小是固定的，是不支持拓展的。
java.lang.StackOverflowError 一般的方法调用是很难出现的，如果出现了可能会是无限递归。
虚拟机栈带给我们的启示：方法的执行因为要打包成栈桢，所以天生要比实现同样功能的循环慢，所以树的遍历算法中：递归和非递归(循环来实现)都有存在的意义。递归代码简洁，非递归代码复杂但是速度较快。
OutOfMemoryError：不断建立线程，JVM 申请栈内存，机器没有足够的内存。
同时要注意，栈区的空间 JVM 没有办法去限制的，因为 JVM 在运行过程中会有线程不断的运行，没办法限制，所以只限制单个虚拟机栈的大小。

示例代码

/*** 栈溢出  -Xss=1m*/
public class StackOverFlow {public void king(){//方法不断执行-栈帧不断入栈(不出栈)king();//}public static void main(String[] args)throws Throwable {StackOverFlow javaStack = new StackOverFlow();javaStack.king();}
}

2、堆溢出

内存溢出：申请内存空间,超出最大堆内存空间。
如果是栈内存溢出，则通过调大 -Xms，-Xmx 参数。
如果不是栈内存泄漏，就是说内存中的对象确实都是必须存活的，那么就应该检查 JVM 的堆参数设置，与机器的内存对比，看是否还有可以调整的空间，再从代码上检查是否存在某些对象生命周期过长、持有状态时间过长、存储结构设计不合理等情况，尽量减少程序运行时的内存消耗。

示例代码1

/*** VM Args：-Xms30m -Xmx30m -XX:+PrintGCDetails* 堆内存溢出（直接溢出）*/
public class HeapOom {public static void main(String[] args){String[] strings = new String[35*1000*1000];  //35m的数组（堆）}
}

示例代码2

/*** VM Args：-Xms30m -Xmx30m     堆的大小30M* 造成一个堆内存溢出(分析下JVM的分代收集)* GC调优---生产服务器推荐开启(默认是关闭的)* -XX:+HeapDumpOnOutOfMemoryError*/
public class HeapOom2 {public static void main(String[] args) throws Exception {List<Object> list = new LinkedList<>(); // list   当前虚拟机栈（局部变量表）中引用的对象int i =0;while(true){i++;if(i%1000==0) Thread.sleep(10);list.add(new Object());// 不能回收2,  优先回收再来抛出异常。}}
}

3、方法区溢出

• 运行时常量池溢出
• 方法区中保存的 Class 对象没有被及时回收掉或者 Class 信息占用的内存超过了我们配置的大小。
  注意 Class 要被回收，条件比较苛刻（仅仅是可以，不代表必然，因为还有一些参数可以进行控制）：
  1、该类所有的实例都已经被回收，也就是堆中不存在该类的任何实例。
  2、 加载该类的 ClassLoader 已经被回收。
  3、 该类对应的 java.lang.Class 对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

示例代码：

/*** 方法区导致的内存溢出* VM Args: -XX:MetaspaceSize=10M -XX:MaxMetaspaceSize=10M* */
public class MethodAreaOutOfMemory {public static void main(String[] args) {while (true) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(TestObject.class);enhancer.setUseCache(false);enhancer.setCallback(new MethodInterceptor() {public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {return arg3.invokeSuper(arg0, arg2);}});enhancer.create();}}public static class TestObject {private double a = 34.53;private Integer b = 9999999;}
}

cglib 是一个强大的，高性能，高质量的 Code 生成类库，它可以在运行期扩展 Java 类与实现 Java 接口。CGLIB 包的底层是通过使用一个小而快的字节码处理框架 ASM，来转换字节码并生成新的类。除了 CGLIB 包，脚本语言例如 Groovy 和 BeanShell，也是使用 ASM 来生成 java 的字节码。当然不鼓励直接使用 ASM，因为它要求你必须对 JVM 内部结构包括 class 文件的格式和指令集都很熟悉。

4、直接内存溢出

直接内存的容量可以通过 MaxDirectMemorySize 来设置（默认与堆内存最大值一样），所以也会出现 OOM 异常；由直接内存导致的内存溢出，一个比较明显的特征是在 HeapDump 文件中不会看见有什么明显的异常情况，如果发生了 OOM，同时 Dump 文件很小，可以考虑重点排查下直接内存方面的原因。

示例代码

/*** 启动前先设置以下VM参数* VM Args：-XX:MaxDirectMemorySize=100m* 限制最大直接内存大小100m*/
public class DirectOom {public static void main(String[] args) {//直接分配128M的直接内存ByteBuffer bb = ByteBuffer.allocateDirect(128*1024*1204);}
}

五、常量池

1、class常量池（静态常量池）

在 class 文件中除了有类的版本、字段、方法和接口等描述信息外，还有一项信息是常量池 (Constant Pool Table)，用于存放编译期间生成的各种字面量和符号引用。

• 字面量
  给基本类型变量赋值的方式就叫做字面量或者字面值。
  比如：String a=“b” ，这里“b”就是字符串字面量，同样类推还有整数字面值、浮点类型字面量、字符字面量。
• 符号引用
  符号引用以一组符号来描述所引用的目标。符号引用可以是任何形式的字面量，JAVA 在编译的时候每个 java 类都会被编译成一个 class文件，但在编译的时候虚拟机并不知道所引用类的地址(实际地址)，就用符号引用来代替，而在类的解析阶段（后续 JVM 类加载会具体讲到）就是为了把这个符号引用转化成为真正的地址的阶段。
  一个 java 类（假设为 People 类）被编译成一个 class 文件时，如果 People 类引用了 Tool 类，但是在编译时 People 类并不知道引用类的实际内存地址，因此只能使用符号引用（org.simple.Tool）来代替。而在类装载器装载 People 类时，此时可以通过虚拟机获取 Tool 类的实际内存地址，因此便可以将符号org.simple.Tool 替换为 Tool 类的实际内存地址。

2、运行时常量池

虚拟机规范中的描述：

运行时常量池（Runtime Constant Pool）是每一个类或接口的常量池（Constant_Pool）的运行时表示形式，它包括了若干种不同的常量：从编译期可知的数值字面量到必须运行期解析后才能获得的方法或字段引用。

运行时常量池是在类加载完成之后，将 Class 常量池中的符号引用值转存到运行时常量池中，类在解析之后，将符号引用替换成直接引用。
运行时常量池在 JDK1.7 版本之后，就移到堆内存中了，这里指的是物理空间，而逻辑上还是属于方法区（方法区是逻辑分区）。
在 JDK1.8 中，使用元空间代替永久代来实现方法区，但是方法区并没有改变，所谓"Your father will always be your father"。变动的只是方法区中内容的物理存放位置，比如运行时常量池和字符串常量池被移动到了堆中（物理上），但是逻辑上它们还是属于方法区的。

3、字符串常量池

字符串常量池这个概念是最有争议的，翻阅了虚拟机规范等很多正式文档，发现没有这个概念的官方定义，我们可从它的作用和 JVM 设计它用于解决什么问题的点来分析它。以 JDK1.8 为例，字符串常量池是存放在堆中，并且与 java.lang.String 类有很大关系。设计这块内存区域的原因在于：String 对象作为 Java数据类型，被使用的频率是最高的，在内存中占据空间也是最大的，因此高效地使用字符串，可以提升系统的整体性能。所以要彻底弄懂字符串常量池，我们的重心其实在于深入理解 String。

六、深入理解String

1、String 类的源码解读（JDK1.8）

通过阅读String源码，我们发现String内部维护的是一个被final修饰的char数组，主要包含两个成员变量：value[]（char数组） 和 hash（用来存放hash值）

String 对象的不可变性

通过源码我们还发现 String 类被 final 关键字修饰了，而且变量 char 数组也被 final 修饰了。
我们知道类被 final 修饰代表该类不可继承，而 char[]被 final+private 修饰，代表了 String 对象不可被更改。Java 实现的这个特性叫作 String 对象的不可变性，即 String 对象一旦创建成功，就不能再对它进行改变。
Java 这样做的好处在哪里呢？

 1. 保证 String 对象的安全性。假设 String 对象是可变的，那么 String 对象将可能被恶意修改。2. 保证 hash 属性值不会频繁变更，确保了唯一性，使得类似 HashMap 容器才能实现相应的 key-value 缓存功能。3. 可以实现字符串常量池。在 Java 中，通常有两种创建字符串对象的方式，一种是通过字符串常量的方式创建，如 String   str=“abc”；另一种是字符串变量通过 new 形式的创建，如 String str = new String(“abc”)。

2、String 的创建方式及内存分配的方式

方式1：String str=“abc”；

当代码中使用这种方式创建字符串对象时，JVM 首先会检查该对象是否在字符串常量池中，如果存在，就返回该对象引用，否则新的字符串将在常量池中被创建。这种方式可以减少同一个值的字符串对象的重复创建，节约内存。（str 只是一个引用）

方式2：String str = new String(“abc”)

首先在编译类文件时，"abc"常量字符串将会放入到常量结构中，在类加载时，“abc"将会在字符串常量池中创建；其次，在调用 new 时，JVM 命令将会调用 String的构造函数，同时引用字符串常量池中的"abc” 字符串，在堆内存中创建一个 String 对象；最后，str 将引用 String 对象。

使用 new，对象会创建在堆中，同时赋值的话，会在常量池中创建一个字符串对象并复制到堆中。
具体的复制过程是先将常量池中的字符串压入栈中，在使用 String 的构造方法是，会拿到栈中的字符串作为构造方法的参数。这个构造函数是一个 char 数组的赋值过程，而不是 new 出来的，所以是引用了常量池中的字符串对象。存在引用关系。

方式3：String str2= “ab”+ “cd”+ “ef”;

编程过程中，字符串的拼接很常见。前面我讲过 String 对象是不可变的，如果我们使用 String 对象相加，拼接我们想要的字符串，是不是就会产生多个对象呢？例如以下代码：

String str= "ab"+ "cd"+ "ef";

理论上这段代码会创建3个对象：首先会生成 ab 对象，再生成 abcd 对象，最后生成 abcdef 对象，非常低效。
实际上，为了提高效率，编译器自动优化了这行代码，编译后的代码，如下

String str= "abcdef";

3、intern方法实战

JDK 1.7后，intern方法会先去查询常量池中是否存在与本对象（调用intern方法的对象）值相同的其他对象或对象引用（判断引用的依据是对象的值相同），如果存在，则返回常量池中的对象或引用，如果不存在，则不会再将字符串拷贝到常量池，而只是在常量池中生成一个对原字符串的引用。简单的说，就是往常量池放的东西变了：原来在常量池中找不到时，复制一个副本放到常量池，1.7后则是将在堆上的地址引用复制到常量池。

几张图轻松理解String.intern()

下面通过几个案例来深入解读String.intern()方法

案例1

示例代码

/**1. 测试String.intern()方法的用法*/
public class TestIntern {public static void main(String[] args){String s2 = new String("ja")+new String("va01");//只在堆中创建了String("java")对象，并未在常量池中创建"java"字符串常量s2.intern();String s3 = new String("java01");s3.intern();String s1 = "java01";//这里的"java"并不是常量池中的字符串常量对象，而是常量池中的引用System.out.println(s2==s1);System.out.println(s2=="java01");System.out.println(s3==s1);System.out.println(s3=="java01");System.out.println(s3.intern()==s2);}
}

运行结果

true
true
false
false
true

结果解析

1. String s2 = new String(“ja”)+new String(“va01”);
   这行代码只在堆中创建了String(“java01”)对象（用A表示），并未在常量池中创建"java"字符串常量
   

2. s2.intern();
   常量池中不存在，所以会在常量池中生成一个原对象的引用，并返回该引用
   

3. String s3 = new String(“java01”);
   在堆中创建一个String(“java”)对象（用B表示），并把常量池中引用Y指向的对象的值赋给对象B的的value
   

4. s3.intern();
   因为常量池中存在引用Y，所以不会再创建，而是直接返回引用
   

5. String s1 = “java01”;
   因为常量池中已存在引用Y，所以直接将引用Y赋值给s1
   
   终上所述，结果显而易见

后语

本系列文章皆是笔者对所学的归纳总结，由于本人学识有限，如有错误之处，望各位看官指正