04-JVM_Stack

JVM_Stack固定大小。那每一个线程的JVM_Stack容量可以在线程创建的时候独立选定。如果线程请求分配的栈容量超过JVM_Stack允许的最大容量，JVM将会抛出StackOverflowError异常
JVM_Stack动态扩展。在尝试扩展的时候无法申请到足够的内存，或者在创建新的线程时没有足够的内存去创建对应的JVM_Stack，那JVM将会抛出OutOfMemoryError异常

/**
 * 栈中的异常：StackOverflowError
 * 当栈深度达到9803的时候，就出现栈内存空间不足
 */
public class StackErrorTest {
    private static int count = 1;
    public static void main(String[] args) {
        System.out.println(count++);
        main(args);
    }
}

6. 设置大小

使用参数-Xss选项来设置线程的最大栈空间，栈的大小直接决定了函数调用的最大可达深度
StackErrorTest程序，通过查看count的值来，观察设置-Xss是否生效

-Xss1m
-Xss1k

4. Stack_Frame

栈的存储单位
面向对象程序设计（Object Oriented Programming）：类和对象
类中基本结构：field（属性、字段、域）、method

1. 栈中存储什么？

每个线程都有自己的栈，栈中的数据都是以栈帧（Stack Frame）的形式存在
线程上正在执行的每个方法都各自对应一个栈帧（Stack Frame）
栈帧是一个内存区块，是一个数据集，维系着方法执行过程中的各种数据信息

2. 栈运行原理

JVM直接对JVM_Stack的操作只有两个，就是对栈帧的压栈、出栈，遵循先进后出，后进先出原则
在一个活动线程中，一个时间点上，只会有一个活动的栈帧
- 当前栈帧（Current Frame）：当前执行方法的栈帧（栈顶栈帧）
- 当前方法（Current Method）：当前栈帧相对应的方法
- 当前类（Current Class）：定义当前方法的类
执行引擎运行的所有字节码指令只针对当前栈帧进行操作
如果在该方法中调用了其他方法，对应的新栈帧会被创建出来，放在栈顶端，成为新的当前帧

/**
 * 栈帧
 */
public class StackFrameTest {

    public static void main(String[] args) {
        method01();
    }

    private static int method01() {
        System.out.println("方法1的开始");
        int i = method02();
        System.out.println("方法1的结束");
        return i;
    }

    private static int method02() {
        System.out.println("方法2的开始");
        int i = method03();;
        System.out.println("方法2的结束");
        return i;
    }

    private static int method03() {
        System.out.println("方法3的开始");
        int i = 30;
        System.out.println("方法3的结束");
        return i;
    }

}

方法1的开始
方法2的开始
方法3的开始
方法3的结束
方法2的结束
方法1的结束

满足栈先进后出，通过Idea的Debugger，能够看到栈信息

不同线程中所包含的栈帧是不允许相互引用的，即不可能在一个栈帧之中引用另外一个线程的栈帧
如果当前方法被调用了，方法返回之际，当前栈帧传回此方法的执行结果给前一个栈帧。接着JVM会丢弃当前栈帧，使得前一个栈帧重新成为当前栈帧
Java方法有两种返回函数的方式
- 一种是正常的函数返回，使用return指令
- 另外一种是抛出异常。不管使用哪种方式，都会导致栈帧被弹出

dreturn => return double;
Ireturn => return int;
return => void

3. 栈帧内部结构

局部变量表（Local Variables）
操作数栈（Operand Stack）（表达式栈）
动态链接（Dynamic Linking）（指向运行时常量池的方法引用）
方法返回地址（Return Address）（方法正常退出、异常退出的定义）
一些附加信息

每个线程都有各自的栈，并且每个栈里面都有很多栈帧，栈帧的大小主要由《局部变量表》《操作数栈》决定

5. Local_Variables

局部变量表：Local Variables，被称之为局部变量数组、本地变量表
定义为一个数字数组，主要用于存储方法参数和局部变量，这些数据类型包括各类基本数据类型、对象引用（reference）、ReturnAddress类型
由于Local_Variables是建立在线程的栈上，是线程的私有数据，因此不存在数据安全问题
Local_Variables的容量大小是在编译期确定下来的，并保存在方法的Code属性的maximum local variables数据项中。在方法运行期间不会改变Local_Variables大小
方法嵌套调用的次数由栈的大小决定。一般来说，栈越大，方法嵌套调用次数越多。对一个函数而言，它的参数和局部变量越多，使得Local_Variables膨胀，它的栈帧就越大，以满足方法调用所需传递的信息增大的需求。进而函数调用就会占用更多的栈空间，导致其嵌套调用次数就会减少
Local_Variables中的变量只在当前方法调用中有效。在方法执行时，JVM通过使用Local_Variables完成参数值到参数变量列表的传递过程。当方法调用结束后，随着栈帧的销毁，Local_Variables也会随之销毁

1. Slot的理解

参数值的存放总是在局部变量数组的index0开始，到数组长度-1的索引结束
Local_Variables，最基本的存储单元是Slot（变量槽）
Local_Variables中存放编译期可知的各种基本数据类型（8种）、引用类型（reference）、ReturnAddress类型的变量
在Local_Variables里，32位以内的类型只占用一个slot（包括ReturnAddress类型），64位的类型（long和double）占用两个slot
- byte、short、char在存储前被转换为int，boolean也被转换为int，0表示false，非0表示true
- long和double则占据两个slot

Local_Variables中的每一个Slot都分配一个访问索引，通过索引即可成功访问到Local_Variables中指定的局部变量值
当一个实例方法被调用的时候，方法参数、局部变量将会按照顺序被复制到Local_Variables中的每一个Slot上
如果需要访问局部变量表中一个64bit的局部变量值时，只需要使用前一个索引即可（eg：访问long、double类型变量）
如果当前帧是由构造方法、实例方法创建的，那么该对象引用this将会存放在index为0的slot处，其余的参数按照参数表顺序继续排列
- 因此static方法不能使用this变量

2. Slot重复利用

栈帧中的Local_Variables中的槽位是可以重用的，如果一个局部变量过了其作用域，那么在其作用域之后申明的新的局部变量，就很有可能会复用过期局部变量的槽位，从而达到节省资源的目的

public static void main(String[] args) {
    int a = 0;
    {
        int b = 0;
        b = a + 1;
    }
    // 变量c使用之前已经销毁的变量b占据的Slot
    int c = a + 1;
}

3. 静态变量、局部变量

变量的分类

按数据类型
- 基本数据类型
- 引用数据类型
按类中声明的位置
1. 成员变量。在使用前，都经历过默认初始化赋值
  - 类变量（static修饰）。静态代码块
    - linking的prepare阶段，给类变量默认赋值；Initialization阶段，给类变量显示赋初始值
  - 实例变量
    - 随着对象创建，会在Heap中分配实例变量空间，并进行默认赋值
2. 局部变量
  - 在使用前必须进行显式赋值，不然编译不通过。Variable 'num' might not have been initialized

静态变量、局部变量对比

参数表分配完毕之后，再根据方法体内定义的变量顺序、作用域进行分配
类变量有两次初始化机会。第一次是在准备阶段，执行系统初始化，对类变量设置默认值；另一次是在初始化阶段，赋定义的初始值
和类变量初始化不同，局部变量表不存在系统初始化过程。这意味着一旦定义了局部变量必须人为初始化，否则无法使用

在栈帧中，与性能调优最密切的就是Local_Variables。在方法执行时，JVM使用Local_Variables完成方法的传递
Local_Variables中的变量也是重要的GC根节点，只要被Local_Variables中直接或间接引用的对象都不会被回收

6. Operand_Stack

操作数栈。JVM的解释引擎是基于栈的执行引擎，其中的栈指的就是Operand_Stack

1. 概念

栈帧还包含一个后进先出（Last - In - First -Out）的操作数栈，也可称之为表达式栈（Expression Stack）
Operand_Stack，在方法执行过程中，根据字节码指令，往栈中写入、提取数据，即入栈（push）、出栈（pop）
- eg：执行复制、交换、求和等操作
Operand_Stack主要用于保存计算过程的中间结果，同时作为计算过程中变量临时的存储空间

Operand_Stack就是执行引擎的工作区。一个方法刚开始执行，新的栈帧随之被创建出来，方法的Operand_Stack是空的
Operand_Stack都拥有一个明确的栈深度，用于存储数值，其所需的最大深度max_stack在编译期就定义好了，保存在方法的Code属性中
- 数组是有长度的，因为数组一旦创建，就是不可变的
栈中的任何一个元素都可以为任意的Java数据类型
- 32bit类型占用一个栈单位深度
- 64bit类型占用两个栈单位深度
Operand_Stack并非采用访问索引的方式来进行数据访问的，而是通过标准的入栈（push）和出栈（pop）操作来完成一次数据访问
被调用的方法带有返回值，其返回值将会被压入当前栈帧的Operand_Stack中，并更新PC下一条要执行的字节码指令
Operand_Stack中元素的数据类型必须与字节码指令的序列严格匹配。这由编译器在编译期间进行验证，同时在类加载过程中的类检验阶段的数据流分析阶段再次验证

2. 代码追踪

public void TestAddOperation() {
    byte i = 15;
    int j = 8;
    int k = i + j;
}

使用javap命令反编译Class文件： javap -v TestAddOperation.class

byte、short、char、boolean内部都是使用int型来进行保存的
同时使用的是iadd进行相加操作，i => 代表int，int类型的加法操作

PC指向0，指令地址为0，使用bipush操作数15入栈

PC + 1，指向下一行代码，将Operand_Stack元素弹出，存储到局部变量表1的位置

为什么局部变量表不是从0开始的呢？
其实局部变量表也是从0开始的，但是因为0号位置存储的是this指针，直接省略了~

PC + 1，让操作数8也入栈，再执行store操作，存入局部变量表中

从Local_Variables中，依次将数据放入Operand_Stack中

将Operand_Stack中的两个元素执行相加操作，并存储在局部变量表3的位置

PC指向10，return直接退出方法
- 局部变量表只存int
- int m = 10; => bipush
- int m = 800; => sipush

// i++和++i区别


// 第一类问题
int i1 = 10;
i1++;

int i2 = 10;
i2++;

// 第二类问题
int i3 = 10;
int i4 = i3++;

int i5 = 10;
int i6 = ++i5;

// 第三类问题
int i7 = 10;
i7 = i7++;

int i8 = 10;
i8 = ++i8;

// 第四类问题
int i9 = 10;
int i10 = i9++ + ++i9;

3. 栈顶缓存技术

栈顶缓存技术（Top Of Stack Cashing）

前面提过，基于栈式架构的JVM所使用的零地址指令更加紧凑，但完成一项操作时，必然需要使用更多的入栈和出栈指令，同时也意味着需要更多的指令分派（instruction dispatch）次数和内存读/写次数
为了解决频繁内存读/写，HotSpot出现了栈顶缓存技术，将栈顶元素全部缓存在物理CPU的寄存器中，以此降低对内存的读/写次数，提升执行引擎的执行效率

寄存器：指令更少，执行速度快

7. Dynamic_Linking

动态链接（指向运行时常量池的方法引用）

动态链接、方法返回地址、附加信息：有时被称为帧数据区

每一个栈帧内部都包含一个指向运行时常量池中该栈帧所属方法的引用。为了支持当前方法能够实现动态链接（Dynamic Linking）
- eg：invokedynamic指令
在Java源文件被编译到字节码文件中时，所有的变量和方法引用都作为符号引用（Symbolic_Reference）保存在Class文件的常量池里。描述一个方法调用了其他方法时，通过常量池中指向方法的符号引用来表示，动态链接就是将这些符号引用转换为调用方法的直接引用

为什么需要运行时常量池？
- 因为不同的方法，都可能调用常量或者方法，所以只需要存储一份即可，节省了空间
常量池作用？
- 为了提供一些符号和常量，便于指令的识别

8. Return_Address

方法返回地址

存放调用该方法的pc的值
一个方法的结束，有两种方式
- 正常退出。正常执行完成
- 异常退出。出现未处理的异常，非正常退出
无论通过哪种方式退出，在方法退出后都返回到该方法被调用的位置
- 正常退出：调用者的pc的值作为返回地址，即调用该方法的指令的下一条指令的地址
- 异常退出：返回地址是要通过异常表来确定，栈帧中一般不会保存这部分信息

1. 正常完成出口

执行引擎遇到任意一个方法返回的字节码指令（return），会有返回值传递给上层的方法调用者
方法在正常调用完成之后，究竟需要使用哪一个返回指令，还需要根据方法返回值的实际数据类型而定
- ireturn (boolean, byte, char, short, int)
- lreturn (Long)
- freturn (Float)
- dreturn (Double)
- areturn
- return (void)。实例初始化方法，类和接口的初始化方法使用

2. 异常完成出口

方法执行过程中遇到异常（Exception），并且异常没有在方法内处理（本方法的异常表中没有搜索到匹配的异常处理器），就会导致方法退出
本质上，方法的退出就是当前栈帧出栈的过程。调用者继续执行下一个栈桢
正常完成出口、异常完成出口的区别：是否给上层调用者产生任何返回值

/*
 * ireturn（boolean、byte、char、short、int）、
 * lreturn（Long）、freturn（Float）、dreturn（Double）、areturn、return（void）
 */
public class ReturnAddressTest {

    // ireturn
    public boolean methodBoolean() {
        return false;
    }

    // ireturn
    public byte methodByte() {
        return 0;
    }

    // ireturn
    public short methodShort() {
        return 0;
    }

    // ireturn
    public char methodChar() {
        return 'a';
    }

    // ireturn
    public int methodInt() {
        return 0;
    }

    // lreturn
    public long methodLong() {
        return 0L;
    }

    // freturn
    public float methodFloat() {
        return 0.0f;
    }

    // dreturn
    public double methodDouble() {
        return 0.0;
    }

    // areturn
    public String methodString() {
        return null;
    }

    // areturn
    public Date methodDate() {
        return null;
    }

    // return
    public void methodVoid() {
    }

  	// return
    static {
        int i = 10;
    }

    public void method2() {

        methodVoid();

        try {
            method1();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void method1() throws IOException {
        FileReader fis = new FileReader("ooxx.txt");
        char[] cBuffer = new char[1024];
        int len;
        while ((len = fis.read(cBuffer)) != -1) {
            String str = new String(cBuffer, 0, len);
            System.out.println(str);
        }
        fis.close();
    }

}

异常表（Exception Table）

9. 一些附加信息

Stack_Frame中还允许携带与JVM实现相关的一些附加信息。eg：对程序调试提供支持的信息

10. 方法调用

解析与分配
在JVM中，将符号引用转换为调用方法的直接引用与方法的绑定机制相关

1. 链接

所有public和protected的实例方法都采用动态绑定机制，会用到方法表
所有私有方法、静态方法、构造器及初始化方法<clinit>都是采用静态绑定机制，不会用到方法表

1. 静态链接

当一个Class文件被装载进JVM，如果被调用的目标方法在编译期可知，且运行期保持不变时，将调用方法的符号引用转换为直接引用的过程

2. 动态链接

如果被调用方法在编译期无法被确定下来，只能在程序运行期，将调用的方法的符号转换为直接引用，这种引用转换过程具备动态性

2. 绑定机制

早期绑定（Early Binding）
晚期绑定（Late Binding）

绑定是一个字段、方法或者类的符号引用被替换为直接引用的过程，这仅仅发生一次

随着高级语言的横空出世，类似于Java一样的基于面向对象的编程语言越来越多，尽管这类编程语言在语法风格上存在一定的差别，但是彼此之间始终保持着一个共性，都支持封装、继承、多态等面向对象特性，既然这一类的编程语言具备多态特性，那么自然也就具备早期绑定和晚期绑定两种绑定方式
Java中任何一个普通方法都具备虚函数的特征，相当于C++中的虚函数（C++中则需要使用关键字virtual来显式定义）。如果在Java程序中不希望某个方法拥有虚函数的特征时，则可以使用关键字final标记这个方法

1. 早期绑定

被调用的目标方法如果在编译期可知，且运行期保持不变，即可将这个方法与所属的类型进行绑定，由于明确了被调用的目标方法究竟是哪一个，因此也就可以使用静态链接的方式将符号引用转换为直接引用

2. 晚期绑定

被调用的方法在编译期无法被确定下来，只能够在程序运行期根据实际的类型绑定相关的方法

/**
 * 早期绑定、晚期绑定
 */
public class AnimalTest {
    public void showAnimal(Animal animal) {
        animal.eat();   // 表现为：晚期绑定
    }

    public void showHunt(Huntable h) {
        h.hunt();       // 表现为：晚期绑定
    }
}

class Animal {
    public void eat() {
        System.out.println("动物进食");
    }
}

interface Huntable {
    void hunt();
}

class Dog extends Animal implements Huntable {
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void hunt() {
        System.out.println("捕食耗子，多管闲事");
    }
}

class Cat extends Animal implements Huntable {

    public Cat() {
        super();        // 表现为：早期绑定
    }

    public Cat(String name) {
        this();         // 表现为：早期绑定
    }

    @Override
    public void eat() {
        super.eat();    // 表现为：早期绑定
        System.out.println("猫吃鱼");
    }

    @Override
    public void hunt() {
        System.out.println("捕食耗子，天经地义");
    }
}

3. 虚方法、非虚方法

非虚方法：方法在编译期就确定了具体的调用版本，在运行时不可变
- 静态方法
- 私有方法
- final方法
- 实例构造器
- 父类方法
虚方法：其他方法

子类对象的多态性使用前提
类的继承关系
方法的重写

VM中提供了以下几条方法调用指令

普通调用指令
- invokestatic：调用静态方法，解析阶段确定唯一方法版本
- invokespecial：调用<init>方法、私有及父类方法，解析阶段确定唯一方法版本
- invokevirtual：调用所有虚方法
- invokeinterface：调用接口方法
动态调用指令
- invokedynamic：动态解析出需要调用的方法，然后执行

前四条指令固化在JVM内部，方法的调用执行不可人为干预，而invokedynamic指令则支持由用户确定方法版本
其中invokestatic、invokespecial调用的方法称为非虚方法，其余的（final修饰的除外）称为虚方法

/**
 * 非虚方法、虚方法测试
 * invokestatic指令、invokespecial指令调用的方法称为非虚方法
 */
class Father {
    public Father() {
        System.out.println("father_ctor");
    }

    public static void showStatic(String str) {
        System.out.println("father static方法" + str);
    }

    public final void showFinal() {
        System.out.println("father final方法");
    }

    public void showCommon() {
        System.out.println("father common方法");
    }
}

public class Son extends Father {

    public Son() {
        // invokespecial
        super();
    }

    public Son(int age) {
        // invokespecial
        this();
    }

    // 不是重写的父类的静态方法，因为静态方法不能被重写！
    public static void showStatic(String str) {
        System.out.println("son " + str);
    }

    private void showPrivate(String str) {
        System.out.println("son private" + str);
    }

    public void show() {
        // invokestatic
        showStatic("ooxx.com");
        // invokestatic
        super.showStatic("good!");
        // invokespecial
        showPrivate("hello!");
        // invokespecial
        super.showCommon();

        // invokevirtual
        // 因为此方法声明有final，不能被子类重写，所以也认为此方法是非虚方法
        // 加上super被明确为invokespecial
        showFinal();


        // 虚方法如下：
        // invokevirtual
        showCommon();
        info();

        MethodInterface in = null;
        // invokeinterface
        in.methodA();
    }

    public void info() {
    }

    public void display(Father f) {
        f.showCommon();
    }

    public static void main(String[] args) {
        Son so = new Son();
        so.show();
    }

}

interface MethodInterface {
    void methodA();
}

4. invokedynamic

JVM字节码指令集一直比较稳定，一直到JDK7中才增加了一个invokedynamic指令，这是Java为了实现【动态类型语言】支持而做的一种改进
但是在JDK7中并没有提供直接生成invokedynamic指令的方法，需要借助ASM底层字节码工具来产生invokedynamic指令。直到JDK8的Lambda表达式的出现，invokedynamic指令的生成，在Java中才有了直接的生成方式
JDK7中增加的动态语言类型支持的本质是对JVM规范的修改，而不是对Java语言规则的修改，这一块相对比较复杂，增加了JVM中的方法调用，最直接的受益者就是运行在Java平台的动态语言的编译器

/**
 * invokedynamic指令
 */
@FunctionalInterface
interface Func {
    public boolean func(String str);
}

public class Lambda {

    public void lambda(Func func) {
        return;
    }

    public static void main(String[] args) {
        Lambda lambda = new Lambda();

        Func func = s -> {
            return true;
        };

        lambda.lambda(func);

        lambda.lambda(s -> {
            return true;
        });
    }

}

1. 动、静态类型语言

区别：对类型的检查是在编译期，还是在运行期。满足前者就是静态类型语言，反之是动态类型语言

静态类型语言：判断变量自身的类型信息
动态类型语言：判断变量值的类型信息，变量没有类型信息，变量值才有类型信息。这是动态语言的一个重要特征

// Java（Java是静态类型语言，编译就进行类型检查）
String info = "mogu blog";

// JS（运行时才进行检查）
var name = "shkstart";
var name = 10;

5. 方法重写本质

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

IllegalAccessError介绍

程序试图访问或修改一个属性或调用一个方法，这个属性、方法，你没有权限访问。一般的，这会引起编译器异常。这个错误如果发生在运行时，就说明一个类发生了不兼容的改变

6. 虚方法表

面向对象编程中，会很频繁的使用到动态分派，如果每次动态分派都要重新在类的方法元数据中搜索合适的目标，就可能影响到执行效率。因此，为了提高性能，JVM在类的方法区建立一个虚方法表（virtual method table）（非虚方法不会出现在表中）来实现。使用索引表来代替查找
每个类中都有一个虚方法表，表中存放着各个方法的实际入口
虚方法表是什么时候被创建？
- 在类加载的链接阶段被创建并开始初始化，类的变量初始值准备完成之后，JVM会把虚方法表也初始化完毕

11. 局部变量线程安全

方法中定义的局部变量是否线程安全？

只有一个线程才可以操作此数据，必是线程安全
多个线程操作此数据，数据是共享数据。不考虑同步机制，存在线程安全问题

总结：如果对象是在内部产生，并在内部消亡，没有返回到外部，那么它就是线程安全的，反之则是线程不安全的

/*
 * 面试题：
 * 方法中局部变量是否线程安全？具体情况具体分析
 *      只有一个线程才可以操作此数据，必是线程安全
 *      多个线程操作此数据，数据是共享数据。不考虑同步机制，存在线程安全问题
 */
public class StringBuilderTest {

    // sb，线程安全的
    public static void method01() {
        // 线程内部创建的，属于局部变量
        StringBuilder sb = new StringBuilder();
        sb.append("a");
        sb.append("b");
    }

    // 线程不安全。有返回值，可能被其它的程序所调用
    public static StringBuilder method04() {
        StringBuilder stringBuilder = new StringBuilder();
        stringBuilder.append("a");
        stringBuilder.append("b");
        return stringBuilder;
    }

    // stringBuilder 线程不安全，操作共享数据
    public static void method02(StringBuilder sb) {
        sb.append("a");
        sb.append("b");
    }


    /**
     * 并发执行，出现线程不安全问题
     */
    public static void method03() {
        StringBuilder sb = new StringBuilder();
        new Thread(() -> {
            sb.append("a");
            sb.append("b");
        }, "t1").start();

        method02(sb);
    }

    // sb线程安全，但String可能线程不安全
    public static String method05() {
        StringBuilder sb = new StringBuilder();
        sb.append("a");
        sb.append("b");
        return sb.toString();
    }
}

12. StackOverflowError

线程请求的栈深度大于JVM允许的最大深度则抛出StackOverflowError

public class StackOverflowTest {
    private static int stackLength = 0;
    private static void println() {
        stackLength++;
        System.err.println("stack length==>" + stackLength);
        println();
    }

    public static void main(String[] args) {
        println();
    }
}

13. OutOfMemoryError

Heap内存溢出
- Java堆内存的OutOfMemoryError是实际应用中最常见的内存溢出异常情况。Java heapspace
DirectMemory溢出
- DirectMemory容量可通过 -XX:MaxDirectMemorySize 指定，如果不指定则默认与Heap最大值（-Xmx）一样

// -Xmx20M -XX:MaxDirectMemorySize=10M
public class DirectMemoryTest {

    public static void main(String[] args) throws IllegalArgumentException, IllegalAccessException {
        Field field = sun.misc.Unsafe.class.getDeclaredFields()[0];
        field.setAccessible(true);
        sun.misc.Unsafe unsafe = (Unsafe) field.get(null);
        while (true) {
            unsafe.allocateMemory(64 * 1024 * 1024);
        }
    }
}