【JVM基础篇】JVM运行时数据区

运行时数据区

JVM将字节码指令加载到内存的时候，会使用到两个内存区，方法区和堆区，这两个区域都属于JVM管理的区域。JVM在运行Java程序过程中管理的内存区域，称之为运行时数据区，除了保存字节码信息之外，还会保存创建的类对象。《Java虚拟机规范》中规定了每一部分的作用。

运行时数据区分为两大类

• 线程不共享：每个线程都有一份程序计数器、Java虚拟机栈、本地方法栈对应的数据，不同线程的数据不进行共享，安全性比较高。当线程结束之后，会将该线程的内存释放。
• 线程共享：在方法区、堆区存放的数据，不同线程可以共享，虽然数据可以共享，但是存在线程安全问题

应用场景

• 解决面试难题
  • Java的内存分成哪几部分？详细介绍一下吧
  • Java内存中哪些部分会内存溢出？
  • JDK7和8中在内存结构上的区别是什么？
• 工作中的实际问题——内存溢出

一、程序计数器

程序计数器（Program Counter Register）也叫PC寄存器，每个线程会通过程序计数器记录当前要执行的的字节码指令的内存地址，字节码指令最初保存在字节码文件中，类加载将字节码读取到内存之后，字节码指令也被保存在内存中，每一行指令都有自己的内存地址。字节码指令最终交给解释器来解释执行，解释器就是跟程序计数器来要字节码指令的内存地址。

一个程序计数器的具体案例：

在加载阶段，虚拟机将字节码文件中的指令读取到内存之后，会将原文件中的偏移量转换成内存地址。每一条字节码指令都会拥有一个内存地址。

在代码执行过程中，程序计数器会记录下一行字节码指令的地址。执行完当前指令之后，虚拟机的执行引擎根据程序计数器执行下一行指令。这里为了简单起见，图片中使用偏移量代替，真实内存中执行时保存的应该是地址。

比如当前执行的是偏移量为0的指令，那么程序计数器中保存的就是下一条的地址（偏移量1）（当前指令执行完之后，程序计数器就会刷新成下一条指令的地址，即程序计数器中保存的永远是下一条字节码指令的地址）。

一路向下执行

一直执行到方法的最后一行指令，此时方法执行return语句，当前方法执行结束，程序计数器中会放入方法出口的地址（栈中讲解，简单来说就是这个B方法结束了，A调用了B，那么要回到A方法）

所以，程序计数器可以控制程序指令的进行，实现分支、跳转、异常等逻辑。不管是分支、跳转、异常，只需要在程序计数器中放入下一行要执行的指令地址即可。例如，如果i不等于0，直接执行偏移量为9的指令。

在多线程执行情况下，CPU是在多个线程中来回切换，反复横跳的，如果从线程A跳到线程B，解释器需要知道线程B之前解释执行到哪个指令，这个就全靠程序计数器，因为它保存了下个指令的地址。Java虚拟机需要通过程序计数器记录CPU切换前解释执行到那一句指令并继续解释运行。

程序计数器的作用

• 控制指令解释执行的顺序
• 用来保存接下来要执行的指令

程序计数器会出现内存溢出吗？

• 内存溢出指的是程序在使用某一块内存区域时，存放的数据需要占用的内存大小超过了虚拟机能提供的内存上限
• 由于每个线程只存储一个固定长度的内存地址，程序计数器不会发生内存溢出
• 程序员无需对程序计数器做任何处理，一切都由JVM进行掌控

栈

栈分为两部分

• Java虚拟机栈：保存java中实现的方法，每次执行方法，都会将该方法的信息保存到栈中
• 本地方法栈：保存的是方法关键字为native的方法（用C++实现的）

hotspot虚拟机中认为两种栈都是保存方法信息，因此直接使用一种栈来保存两个栈的信息

二、Java虚拟机栈

Java虚拟机栈（Java Virtual Machine Stack）采用栈的数据结构来管理方法调用中的基本数据，先进后出（First In Last Out）,每一个方法的调用使用一个栈帧（Stack Frame）来保存。

public class MethodDemo {   
    public static void main(String[] args) {        
         study();    
     }

    public static void study(){
        eat();

        sleep();
    }   
    
    public static void eat(){       
         System.out.println("吃饭");   
    }    
    
    public static void sleep(){        
        System.out.println("睡觉");    
        }
  }

main方法执行时，会创建main方法的栈帧，栈帧用来保存栈的基本信息：

接下来执行study方法，会创建study方法的栈帧

进入eat方法，创建eat方法的栈帧

eat方法执行完之后，会弹出它的栈帧，方法执行完成之后，栈帧就没有必要保存了：

然后调用sleep方法，创建sleep方法栈帧

最后study方法结束之后弹出栈帧，main方法结束之后弹出main的栈帧。

在IDEA中也可以看到对应的栈帧：

package chapter03.frame;

/**
 * 栈帧测试1
 */
public class FrameDemo {
    public static void main(String[] args) {
        A();
    }

    public static void A() {
        System.out.println("A执行了...");
        B();
    }

    public static void B() {
        System.out.println("B执行了...");
        C();
    }

    public static void C() {
        System.out.println("C执行了...");
        throw new RuntimeException("测试");
    }
}

在C执行了输出那行打上断点debug之后会出现栈帧内容：

栈的数据是不能线程共享的，所以每个线程都会保存自己的栈帧

Java虚拟机栈随着线程的创建而创建，而回收则会在线程销毁时进行（Java虚拟机栈的生命周期和线程的生命周期是一样的）。由于方法可能会在不同线程中执行，每个线程都会包含一个自己的虚拟机栈。如下就有两个线程的虚拟机栈，main线程和线程A。

栈帧存放什么数据

Java虚拟机栈的栈帧中主要包含三方面的内容：

• 局部变量表：局部变量表的作用是在运行过程中存放所有的局部变量
• 操作数栈：操作数栈是栈帧中虚拟机在执行指令过程中用来存放临时数据的一块区域
• 帧数据：帧数据主要包含动态链接、方法出口、异常表的引用

局部变量表

局部变量表的作用是在方法执行过程中存放所有的局部变量，局部变量表分为两种

• 一种是字节码文件中的
• 另一种是栈帧中的也就是保存在内存中，栈帧中的局部变量表是根据字节码文件中的内容生成的。

字节码文件的局部变量表

编译成字节码文件的时候，就可以确定局部变量表的内容。

public static void test1(){
    int i = 0;
    long j = 1;
}

test1方法的局部变量表如下：

• Nr. ：保存局部变量的编号

• 起始PC
  

  • 比如i这个变量，它的起始PC是2，代表从lconst_1这句指令开始才能使用i，长度为3，也就是2-4这三句指令都可以使用i。为什么从2才能使用，因为0和1这两句字节码指令还在处理int i = 0这句赋值语句
  • j这个变量只有等3指令执行完之后也就是long j = 1代码执行完之后才能使用，所以起始PC为4，只能在4这行字节码指令中使用，所以长度为1

• 长度：定义了生效范围，是让指令的执行更加安全，避免在生效范围外使用局部变量

栈帧的局部变量表

上面的局部变量是字节码文件的局部变量表，接下来看下栈帧中的局部变量表。栈帧中的局部变量表是一个数组，数组中每一个位置称之为槽(slot) ，long和double类型占用两个槽，其他类型占用一个槽。在日常写代码的时候，经常会使用局部变量来保存其他对象的引用，这些引用也是占用一个槽

i占用数组下标为0的位置，j占用数组下标1-2的位置。到这里就可以理解字节码中局部变量表的意思了

刚才看到的是静态方法，在实例的方法中的序号为0的位置存放的是this，指的是当前调用方法的对象，运行时会在内存中存放实例对象的地址，可以通过这个内存地址访问当前对象的数据

局部变量表里面还可以存储方法参数，其顺序与方法中参数定义的顺序一致。局部变量表保存的内容有：实例方法的this对象，方法的参数，方法体中声明的局部变量。

test3方法中包含两个参数k,m，这两个参数也会被加入到局部变量表中。

思考题：以下代码的局部变量表中会占用几个槽？

public void test4(int k,int m){
    {
        int a = 1;
        int b = 2;
    }
    {
        int c = 1;
    }
    int i = 0;
    long j = 1;
}

可能会误以为是9个，但是实际是6个。因为为了节省空间，局部变量表中的槽是可以复用的，一旦某个局部变量不再生效，当前槽就可以被其他局部变量再次被使用。

1、方法执行时，实例对象this、k、m 会被放入局部变量表中，占用3个槽

2、将1的值放入局部变量表下标为3的位置上，相当于给a进行赋值。

3、将2放入局部变量表下标为4的位置，给b赋值为2。

4、代码块结束，ab已经脱离了生效范围，所以下标为3和4的这两个位置可以复用。此时c的值1就可以放入下标为3的位置。

5、第二个代码块结束后，脱离c的生效范围之后，给i赋值就可以复用c的位置。

6、最后放入j，j是一个long类型，占用两个槽。但是可以复用b所在的位置，所以占用4和5这两个位置

所以，局部变量表数值的长度为6。这一点在编译期间就可以确定了，运行过程中只需要在栈帧中创建长度为6的数组即可。

操作数栈

• 操作数栈是栈帧中虚拟机在执行指令过程中用来存放中间数据（临时数据）的一块区域。他是一种栈式的数据结构，如果一条指令将一个值压入操作数栈，则后面的指令可以弹出并使用该值。
• 将一些临时数据，比如常量，先放到操作数栈中，然后通过下一个指令从操作数栈中取出常量，放到局部变量表
• 操作数栈要分配多大的空间呢，其实在编译期就可以确定操作数栈的最大深度，从而在执行时正确的分配内存大小

比如之前的相加案例中，执行每个指令，看操作数栈中最大出现多少个数据，这个数量即操作数栈最大的深度

相加之后，只剩下一个1

所以操作数栈的深度会定义为2。

帧数据

• 局部变量表和操作数栈的数据是需要按照虚拟机规范来存储的，但是栈数据允许自己定义一些数据
• 帧数据主要包含动态链接、方法出口、异常表的引用。

动态链接

当前类的字节码指令引用了其他类的属性或者方法时，需要将符号引用（编号）转换成对应的运行时常量池中的内存地址。动态链接就保存了编号到运行时常量池的内存地址的映射关系。

• getstatic指令：获取某一个类的静态变量
• 因为使用了其他类的属性和方法，该符号引用不会在连接阶段变成内存的直接引用，虚拟机在执行该方法的字节码指令之前，在栈帧中保存#10这个符号引用到运行时常量池的引用关系，这个引用关系就是保存在动态链接中，在执行相关指令的时候，再根据动态链接来找到其他类的属性或方法的内存地址。
  

方法出口

方法出口指的是方法在正确或者异常结束时，当前栈帧会被弹出，同时程序计数器应该指向上一个栈帧中的下一条指令的地址。所以在当前栈帧中，需要存储此方法出口的地址。

当sleep方法结束之后，其栈帧会从虚拟机栈中弹出，这是程序计数器重新指向study方法，但是如何知道之前study方法执行到哪个指令了呢，其实是sleep方法的栈帧保存了study方法执行到了的指令的地址，在sleep栈帧弹出之前，将该指令地址传给程序计数器，将当前栈帧中存储的下一个栈帧指令地址称为方法出口

异常表

• 在编译阶段，如果发现方法中有关于异常的捕获，那么在生成方法的指令的时候，为这个方法生成一张异常表。
• 异常表存放的是代码中异常的处理信息，包含了异常捕获的生效范围以及异常发生后跳转到的字节码指令位置。

如下案例：i=1这行源代码编译成字节码指令之后，会包含偏移量2-4这三行指令（起始PC、结束PC指的是异常捕获生效的范围，即在2、3、4三行指令中捕获异常）。其中2-3是对i进行赋值1的操作，4的没有异常就跳转到10方法结束。如果出现异常的情况下，继续执行到7这行指令（即跳转PC），7会将异常对象放入操作数栈中，这样在catch代码块中就可以使用异常对象了。接下来执行8-9，对i进行赋值为2的操作。

所以异常表中，异常捕获的起始偏移量就是2，结束偏移量是4，在2-4执行过程中抛出了java.lang.Exception对象或者子类对象，就会将其捕获，然后跳转到偏移量为7的指令。

栈内存溢出

• Java虚拟机栈如果栈帧过多，占用内存超过栈内存可以分配的最大大小就会出现内存溢出。
• Java虚拟机栈内存溢出时会出现StackOverflowError的错误，同时这个线程也会停止执行

如果我们不指定栈的大小，JVM 将创建一个具有默认大小的栈。大小取决于操作系统和计算机的体系结构。

我们来模拟下栈内存的溢出情况，看栈能存放多少个栈帧:

public static int count = 0;
//递归方法调用自己
public static void recursion(){
    System.out.println(++count);
    recursion();
}

使用递归让方法调用自身，但是不设置退出条件。定义调用次数的变量，每一次调用让变量加1。查看错误发生时总调用的次数。

执行之后可以打印出溢出时总栈帧的数量，并且发现虚拟机已经抛出了StackOverflow的错误。

设置Java虚拟机栈大小

要修改Java虚拟机栈的大小，可以使用虚拟机参数 -Xss 。

• 语法：-Xss栈大小（单位可选，不写默认是字节）
• 单位：字节（默认，必须是 1024 的倍数）、k或者K(KB)、m或者M(MB)、g或者G(GB)

例如：

-Xss1048576 
-Xss1024K      
-Xss1m
-Xss1g

操作步骤如下，不同IDEA版本的设置方式会略有不同：

1、点击修改配置Modify options

2、点击Add VM options

3、添加参数

调成512k之后，明显发现最大栈帧数量减少了：

注意事项：

1、与-Xss类似，也可以使用 -XX:ThreadStackSize 调整标志来配置堆栈大小。

格式为： -XX:ThreadStackSize=1024

2、HotSpot JVM对栈大小的最大值和最小值有要求：

​ 比如测试如下两个参数，会直接报错:

• -Xss1k
• -Xss1025m

Windows（64位）下的JDK8测试最小值为180k，最大值为1024m。

3、局部变量过多、操作数栈深度过大也会影响栈内存的大小。我们在这段代码中添加一些局部变量。

//递归方法调用自己
public static void recursion() {
    long a,b,c,d,f,g,h,i,j,k;
    System.out.println(++count);
    recursion();
}

使用默认大小来测试之后，发现栈帧数量从10000+减少了到8000+

一般情况下，工作中即便使用了递归进行操作，栈的深度最多也只能到几百，不会出现栈的溢出。所以此参数可以手动指定为-Xss256k节省内存。

三、本地方法栈

• Java虚拟机栈存储了Java方法调用时的栈帧，而本地方法栈存储的是native本地方法的栈帧。本地方法栈和Java虚拟机栈的处理思路和栈帧中存放的数据差不多。
• 在Hotspot虚拟机中，Java虚拟机栈和本地方法栈实现上使用了同一个栈空间。本地方法栈会在栈内存上生成一个栈帧，临时保存方法的参数同时方便出现异常时也把本地方法的栈信息打印出来。

比如测试下这段代码：

/**
 * 本地方法栈
 */
public class NativeDemo1 {
    public static void main(String[] args) {
        try {
            FileOutputStream fileOutputStream = new FileOutputStream("E:\\123.txt");
            // 这个文件不存在，肯定会抛异
            fileOutputStream.write(1);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

执行之后发生异常，会打印出所有栈帧的名字：

open0是一个本地方法，所以创建了本地方法的栈帧。本地方法和Java虚拟机方法的栈帧在一个栈上。

四、堆内存

• 一般Java程序中堆内存是空间最大的一块内存区域。创建出来的对象（包括对象的属性）都存在于堆上。
• 如何访问堆里面的对象？
  • 栈上的局部变量表中，可以存放堆上对象的引用。
  • 静态变量也可以存放堆对象的引用，通过静态变量就可以实现对象在线程之间共享。

public class Test {    
    public static void main(String[] args) {        
        Student s1 = new Student();        
        s1.name = "张三";       
        s1.age = 18;       
        s1.id = 1;
        s1.printTotalScore();        
        s1.printAverageScore();        
        
        Student s2 = new Student();       
        s2.name = "李四";        
        s2.age = 19;        
        s2.id= 2;        
        s2.printTotalScore();        
        s2.printAverageScore();    
    }
}

这段代码中通过new关键字创建了两个Student类的对象，这两个对象会被存放在堆上。在栈上通过s1和s2两个局部变量保存堆上两个对象的地址，从而实现了引用关系的建立。

注意：

• 使用局部变量的方式保存内存地址，在别的线程中是无法使用这两个对象的，因为Java虚拟机栈的信息不是线程共享的
• 但是如果使用静态变量存储堆中对象的引用的话，通过静态变量可以实现对象的跨线程共享

堆内存的溢出

通过new关键字不停创建对象，放入集合中，模拟堆内存的溢出，观察堆溢出之后的异常信息。

package chapter03.heap;

import java.io.IOException;
import java.util.ArrayList;

/**
 * 堆内存的使用和回收
 */
public class Demo1 {
    public static void main(String[] args) throws InterruptedException, IOException {
        ArrayList<Object> objects = new ArrayList<Object>();
        System.in.read();
        while (true){
            objects.add(new byte[1024 * 1024 * 100]);
            Thread.sleep(1000);
        }
    }
}

堆内存大小是有上限的，当对象一直向堆中放入对象达到上限之后，就会抛出OutOfMemory错误。在这段代码中，不停创建100M大小的字节数组并放入ArrayList集合中，最终超过了堆内存的上限。抛出如下错误：

堆中三个重要的值

堆空间有三个需要关注的值，used、total、max。

• used指的是当前已使用的堆内存
• total是java虚拟机已经分配的可用堆内存
• max是java虚拟机可以分配的最大堆内存（用的内存接近total之后，total会变大，可以继续用到max）。

堆内存used total max三个值可以在Arthas中通过dashboard命令看到。

手动指定刷新频率（不指定默认5秒一次）：dashboard –i 刷新频率(毫秒)

使用memory命令也是OK的，只是不能刷新，但是显示的信息比较简洁

随着堆中的对象增多，当total可以使用的内存即将不足时，java虚拟机会继续分配内存给堆。

此时used达到了total的大小，Java虚拟机会向操作系统申请更大的内存。

但是这个申请过程不是无限的，total最多只能与max相等。

那么是不是当used = max = total的时候，堆内存就溢出了呢？

不是，堆内存溢出的判断条件比较复杂，在下一章《垃圾回收器》中会详细介绍。

为什么total这么小就报内存溢出了呢？

因为Arthas的输出是间隔刷新的，内存溢出的时候，Arthas不一定能及时打印刚好溢出时的内存大小

但是用了这个方法之后，可以看到total还是小于max

设置堆的大小

如果不设置任何的虚拟机参数，max默认是系统内存的1/4，total默认是系统内存的1/64。在实际应用中一般都需要设置total和max的值。 Oracle官方文档：https://docs.oracle.com/javase/8/docs/technotes/tools/unix/java.html

要修改堆的大小，可以使用虚拟机参数 –Xmx（max最大值）和-Xms (初始的total)。

语法：-Xmx值 -Xms值

单位：字节（默认，必须是 1024 的倍数）、k或者K(KB)、m或者M(MB)、g或者G(GB)

限制：Xmx必须大于 2 MB，Xms必须大于1MB

-Xms6291456
-Xms6144k
-Xms6m
-Xmx83886080
-Xmx81920k
-Xmx80m

这样可以将max和初始的total都设置为4g，在启动后就已经获得了最大的堆内存大小。运行过程中不需要向操作系统申请。

为什么arthas中显示的heap堆大小与设置的值不一样呢？（按理说应该是4096M）

arthas中的heap堆内存使用了JMX技术中内存获取方式，这种方式与垃圾回收器有关，计算的是可以分配对象的内存（有部分内存是不能使用的），不是整个内存。

建议：

• Java服务端程序开发时，建议将-Xmx和-Xms设置为相同的值，这样在程序启动之后可使用的总内存就是最大内存，而无需向java虚拟机再次申请，减少了申请并分配内存时间上的开销，同时也不会出现内存过剩之后堆收缩的情况。
• -Xmx具体设置的值与实际的应用程序运行环境有关，在《实战篇》中会给出设置方案。

五、方法区

方法区是存放基础信息的位置，线程共享，主要包含三部分内容：

• 类的元信息（基本信息就是元信息），保存了所有类的基本信息
• 运行时常量池，保存了字节码文件中的常量池内容
• 字符串常量池，保存了字符串常量

1、类的元信息

方法区是用来存储每个类的基本信息（元信息），一般称之为InstanceKlass对象。在类的加载阶段完成。其中就包含了类的字段、方法等字节码文件中的内容，同时还保存了运行过程中需要使用的虚方法表（实现多态的基础）等信息。

其实基本信息、常量池、字段、方法这些是放在额外的内存中，InstanceKlass中只是存放他们的内存引用

2、运行时常量池

常量池中存放的是字节码中的常量池内容。

字节码文件中通过编号查表的方式找到常量，这种常量池称为静态常量池。当常量池加载到内存中之后，可以通过内存地址快速定位到常量池中的内容，这种常量池称为运行时常量池。通过内存地址来访问常量池的内容，性能会更高一点

方法区的实现

方法区是《Java虚拟机规范》中设计的虚拟概念，每款Java虚拟机在实现上都各不相同。Hotspot中不同版本用到的技术都是不同的：

• JDK7及之前的版本将方法区存放在堆区域中的永久代空间(方法区放在堆里面，这段空间称为永久代)，堆的大小由虚拟机参数来控制。

[JDK7之前]

[JDK7]

• JDK8及之后的版本将方法区存放在元空间中，元空间位于操作系统维护的直接内存中（操作系统自己的内存，独立于JVM之外的，对内存的使用相对来说比较灵活，不会受到JVM内存限制），默认情况下只要不超过操作系统承受的上限，可以一直分配，这样就可以有非常大的方法区空间了。

可以通过arthas的memory命令看到方法区的名称以及大小：

• JDK7及之前的版本查看ps_perm_gen属性。永久代空间是设置在堆上的，所以有一个最大空间

• JDK8及之后的版本查看metaspace属性。元空间是存储在操作系统内存中的，所以上限为操作系统的内存上限
  

方法区的溢出

通过ByteBuddy框架，动态创建类并将字节码数据加载到内存中。通过死循环不停地加载到方法区（不停地往方法区中添加类信息），观察方法区是否会出现内存溢出的情况。分别在JDK7和JDK8上运行上述代码。

ByteBuddy

ByteBuddy是一个基于Java的开源库，用于生成和操作Java字节码。

1.引入依赖

<dependency>
    <groupId>net.bytebuddy</groupId>
    <artifactId>byte-buddy</artifactId>
    <version>1.12.23</version>
 </dependency>

2.创建ClassWriter对象

 ClassWriter classWriter = new ClassWriter(0);

3.调用visit方法，创建字节码数据。

classWriter.visit(Opcodes.V1_7,Opcodes.ACC_PUBLIC,name,null ,"java/lang/Object",null);
byte[] bytes = classWriter.toByteArray();

代码：

package chapter03.methodarea;

import net.bytebuddy.jar.asm.ClassWriter;
import net.bytebuddy.jar.asm.Opcodes;

import java.io.IOException;

/**
 * 方法区的溢出测试
 */
public class Demo1 extends ClassLoader {
    public static void main(String[] args) throws IOException {
        System.in.read();
        Demo1 demo1 = new Demo1();
        int count = 0;
        while (true) {
            // 类名
            String name = "Class" + count;
            ClassWriter classWriter = new ClassWriter(0);
            // Opcodes.V1_8 JDK8
            classWriter.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null
                    , "java/lang/Object", null);
            byte[] bytes = classWriter.toByteArray();
            demo1.defineClass(name, bytes, 0, bytes.length);
            System.out.println(++count);
        }
    }
}

实验发现，JDK7上运行大概十几万次，就出现了错误。

在JDK8上运行百万次，程序都没有出现任何错误，但是内存会直线升高。这说明JDK7和JDK8在方法区的存放上，采用了不同的设计。

• JDK7将方法区存放在堆区域中的永久代空间，堆的大小由虚拟机参数-XX:MaxPermSize=值来控制。
• JDK8将方法区存放在元空间中，元空间位于操作系统维护的直接内存中，默认情况下只要不超过操作系统承受的上限，可以一直分配。可以使用**-XX:MaxMetaspaceSize=值****将元空间最大大小进行限制（为啥要限制大小，公司的服务器可能部署了多个程序，假如一个程序的方法区出现了问题，可能占用大量内存，进而影响到其他程序，一般设置为256兆即可）**。

在JDK8中将最大元空间内存设置为256m，再次测试

这次就出现了MetaSpace溢出的错误：

3、字符串常量池(StringTable)

字符串常量池存储在代码中定义的常量字符串内容。比如“123” 这个123就会被放入字符串常量池。

如下代码编译成字节码文件的时候，会将"abc"放入到静态常量池中。字节码信息读取到内存之后，字符串就会被直接放入字符串常量池。

• new String()在堆上创建String对象，并通过局部变量s1引用堆上的对象。

• 接下来通过s2局部变量引用字符串常量池的abc。

所以s1和s2指向的不是同一个对象，打印出false。

字符串常量池和运行时常量池有什么关系？

早期设计时，字符串常量池是属于运行时常量池的一部分，他们存储的位置也是一致的。后续做出了调整，将字符串常量池和运行时常量池做了拆分。

StringTable的练习题1：

/**
 * 字符串常量池案例
 */
public class Demo2 {
    public static void main(String[] args) {
        String a = "1";
        String b = "2";
        String c = "12";
        String d = a + b;
        System.out.println(c == d);
    }
}

1、首先将1放入字符串常量池，通过局部变量a引用字符串常量池中的1字符串。

2、同理处理b和c：

3、将a和b指向的字符串进行连接，本质上就是使用StringBuilder进行连接，最后创建了一个新的字符串放入堆中。然后将局部变量d指向堆上的对象。

4、所以c和d指向的不是同一个对象（一个在常量池中，一个在堆中），打印出的结果就是false。

StringTable的练习题2：

package chapter03.stringtable;

/**
 * 字符串常量池案例
 */
public class Demo3 {
    public static void main(String[] args) {
        String a = "1";
        String b = "2";
        String c = "12";
        String d = "1" + "2";
        System.out.println(c == d);
    }
}

编译之后的字节码指令如下：

说明在编译阶段，已经将1和2进行连接，最终生成12的字符串常量池中的结果。所以返回结果就是true，c和d都指向字符串常量池中的对象。

总结一下：区别在于，加号左右是变量还是常量

String.intern()作用

String.intern()方法是可以手动将字符串放入字符串常量池中，分别在JDK6 JDK8下执行代码，JDK6 中结果是false false ，JDK8中是true false。

使用intern()可以让相同的数据只存储一份，如果读取那种有很多重复内容的文件的时候，可以考虑使用intern进行优化。intern()方法执行结束之后，返回常量池中的内存地址

package chapter03.stringtable;

/**
 * intern案例
 */
public class Demo4 {
    public static void main(String[] args) {
        String s1 = new StringBuilder().append("think").append("123").toString();

        System.out.println(s1.intern() == s1);
//        System.out.println(s1.intern() == s1.intern());

        String s2 = new StringBuilder().append("ja").append("va").toString();

        System.out.println(s2.intern() == s2);
    }
}

先来分析JDK6中，代码执行步骤如下：

1、使用StringBuilder的将think和123拼接成think123，转换成字符串，在堆上创建一个字符串对象。局部变量s1指向堆上的对象。

2、调用s1.intern方法，会在字符串常量池中创建think123的对象，最后将对象引用返回。所以s1.intern和s1指向的不是同一个对象。打印出false。

3、同理，通过StringBuilder在堆上创建java字符串对象。这里注意字符串常量池中本来就有一个java字符串对象，这是java虚拟机自身使用的所以启动时就会创建出来。

4、调用s2.intern发现字符串常量池中已经有java字符串对象了，就将引用返回。所以s2.intern指向的是字符串常量池中的对象，而s2指向的是堆中的对象。打印结果为false。

接下来分析JDK7中，JDK7及之后版本中由于字符串常量池在堆上，所以intern () 方法会把第一次遇到的字符串的引用放入字符串常量池。

代码执行步骤如下：

1、执行第二句代码时，由于字符串常量池中没有think123的字符串，所以直接创建一个引用，指向堆中的think123对象。所以s1.intern和s1指向的都是堆上的对象，打印结果为true。

2、s2.intern方法调用时，字符串常量池中已经有java字符串了，所以将引用返回，而不是指向堆中的地址。这样打印出来的结果就是false。

后续JDK版本中，如果Java虚拟机不需要使用java字符串，那么字符串常量池中就不会存放java。打印结果有可能会出现两个true。

静态变量存储在哪里呢？

• JDK6及之前的版本中，静态变量是存放在方法区中的，也就是永久代。
• JDK7及之后的版本中，静态变量是存放在堆中的Class对象中，脱离了永久代。具体源码可参考虚拟机源码：BytecodeInterpreter针对putstatic指令的处理。

直接内存

直接内存（Direct Memory）并不在《Java虚拟机规范》中存在，所以并不属于Java运行时的内存区域。

在 JDK 1.4 中引入了 NIO 机制（网络IO、Netty底层都是NIO机制），使用了直接内存，主要为了解决以下两个问题:

1. Java堆中的对象如果不再使用要回收，回收时会影响对象的创建和使用，系统出现卡顿。使用直接内存的话，直接内存的回收不会影响到堆上的对象，系统就不会卡顿。
2. IO操作比如读文件，需要先把文件读入直接内存（缓冲区）再把数据复制到Java堆中（效率较低，使用直接内存方式，文件读写效率更高）。

现在直接放入直接内存即可，同时Java堆上维护直接内存的引用，减少了数据复制的开销。写文件也是类似的思路。

使用堆创建对象的过程：

使用直接内存创建对象的过程，不需要进行复制对象，堆上只需要保存一个对象引用，数据直接存放在直接内存中：

使用方法：

要创建直接内存上的数据，可以使用ByteBuffer。

语法： ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);在直接内存上面分配内存空间，size：内存空间大小，

注意事项： arthas的memory命令可以查看直接内存大小，属性名direct。

代码：

package chapter03.direct;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

/**
 * 直接内存的使用和回收
 */
public class Demo1 {
    public static int size = 1024 * 1024 * 100; //100mb
    public static List<ByteBuffer> list = new ArrayList<ByteBuffer>();
    public static int count = 0;

    public static void main(String[] args) throws IOException, InterruptedException {
        System.in.read();
        while (true) {
            //1.创建DirectByteBuffer对象并返回
            //2.在DirectByteBuffer构造方法中，向操作系统申请直接内存空间
            ByteBuffer directBuffer = ByteBuffer.allocateDirect(size);
            //directBuffer = null;

            list.add(directBuffer);
            System.out.println(++count);
            Thread.sleep(5000);
        }

    }
}

运行之后，用arthas监控发现，每隔5秒直接内存会增长100M：

如果将Thread.sleep(5000);注释掉，让直接内存快速大量分配。操作系统内存不足时就会报错：

但是工作中服务器上有可能部署了其他应用，为了避免将内存耗尽，需要设置直接内存的最大值。如果需要手动调整直接内存的大小，可以使用XX:MaxDirectMemorySize=大小。单位k或K表示千字节，m或M表示兆字节，g或G表示千兆字节。默认不设置该参数情况下，JVM 自动选择最大分配的大小。那这个大小设置为多少比较好呢，应该对程序进行压力测试，然后看压力测试的最大值更大一些。

以下示例以不同的单位说明如何将 直接内存大小设置为 1024 KB：

-XX:MaxDirectMemorySize=1m
-XX:MaxDirectMemorySize=1024k
-XX:MaxDirectMemorySize=1048576

在Idea中设置直接内存最大值为1g：

直接循环11次之后，超过最大值就会报错：

文章说明

该文章是本人学习 黑马程序员 的学习笔记，文章中大部分内容来源于 黑马程序员 的视频黑马程序员JVM虚拟机入门到实战全套视频教程，java大厂面试必会的jvm一套搞定（丰富的实战案例及最热面试题），也有部分内容来自于自己的思考，发布文章是想帮助其他学习的人更方便地整理自己的笔记或者直接通过文章学习相关知识，如有侵权请联系删除，最后对 黑马程序员 的优质课程表示感谢。