一、JVM运行机制（自动内存管理机制）

最新推荐文章于 2022-12-05 20:10:25 发布

陈彬_smile

最新推荐文章于 2022-12-05 20:10:25 发布

阅读量595

点赞数

分类专栏： JVM 文章标签： JVM Java 虚拟机

本文链接：https://blog.csdn.net/chenbin1991smile/article/details/102769362

版权

JVM 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

1.JVM启动流程

1.1创建JVM装载环境和配置；

1.2装载JVM.dll；

1.3初始化JVM.dll并挂界到JNIENV(JNI调用接口)实例；

1.4调用JNIEnv实例装载并处理class类。

2.JVM基本结构

JVM启动后，对操作系统来说，JVM是一个进程。它包括：

类加载子系统（classLoader）,运行时数据区，执行引擎，本地方法接口

2.2运行时数据区：

PC寄存器：

一个较小块的内存空间，每个线程都拥有一个PC寄存器，在创建线程时创建，

指向下一条指令（虚拟机字节码指令）的地址，执行本地方法时，PC寄存器的值为undefined，

此内存区域是唯一一个没有规定OutOfMemoryError的区域。

Java方法区：

保存装载的类信息，类型的常量池，方法，字段信息，方法字节码

jdk6时，String等常量信息置于方法区

jdk7时，已经移动到了堆

方法区通常和永久区（perm-永久代）关联在一起

Java堆：

应用系统对象都保存在Java堆中，所有线程共享Java堆，

对于分代GC来说，堆也是分代回收的

eden(伊甸区)，from survivor(s0) tosurvivor(s1) tenured

Java栈

Java栈是线程私有的，由一系列帧组成

帧保存一个方法的局部变量，操作数，常量池指针，

每一次方法调用创建一个帧（stack frame）,并压栈。

小对象（一般几十个bytes），在没有逃逸的情况下，可以直接分配在栈上，

直接分配在栈上，可以自动回收，减轻GC压力，

大对象或者逃逸对象无法栈上分配。

本地方法栈：执行native方法

内存模型：每个线程有一个工作内存和主存独立，工作内存存放主存中变量值的拷贝。

package com.jvm.oom;

/**
 * Java方法区，Java堆，Java栈
 * Created by chenbin on 2019\8\30 0030.
 */
//运行时，jvm把appmian的信息放入方法区
public class AppMain {
    //mian方法本身放在方法区
    public static void main(String[] args) {
        //test1是引用，放在栈区里；simple是自定义对象，放在堆里面
        Sample test1 = new Sample("测试1");
        Sample test2 = new Sample("测试2");

        test1.printName();
        test2.printName();
    }
}

2.3outOfMemoryError异常

-Xms 堆的最小值，-Xmx 堆的最大值，设置成一样可以避免自动扩展

-Xmn 年轻代的大小 -XX:SurvivorRatio=8，s1:s2:tenured=1:1:8

-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=8

堆溢出示例：

设置JVM参数：-verbose:gc -Xms20M -Xmx20M -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=6

package com.jvm.oom;

import java.util.ArrayList;
import java.util.List;

/**
 * 堆内存溢出
 * 该示例需要设置JVM参数：
 * -verbose:gc -Xms20M -Xmx20M  -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=6
 *
 * 堆的最小值 -Xms 堆和最大值 -Xmx 设置成一样可以避免自动扩展
 * -Xms20M 初始化堆内存大小(最小空间)
   -Xmx20M 堆内存最大值
   -Xmn10M 设置年轻代大小为10M。
   -Xss:设置每个线程的堆栈大小
   -XX:+PrintGcDetails 用于打印GC的日志信息
   -verbose:gc 用于查看Java垃圾收集的结果

   -XX:SurvivorRatio=6 ，设置的是Eden区与每一个Survivor区的比值，可以反推出占新生代的比值，
    Eden为6, 两个Survivor为2, Eden占新生代的3/4, 每个Survivor占1/8，两个占1/4
 * Created by chenbin on 2019\9\1 0001.
 */
public class HeapOOM {
    static class OOMObject{}

    public static void main(String[] args) {
        List<OOMObject> list = new ArrayList<>();
        while (true) {
            list.add(new OOMObject());
        }
    }
}

/**
 * Exception in thread "main" java.lang.OutOfMemoryError: Java heap space
 at java.util.Arrays.copyOf(Arrays.java:3210)
 at java.util.Arrays.copyOf(Arrays.java:3181)
 at java.util.ArrayList.grow(ArrayList.java:261)
 at java.util.ArrayList.ensureExplicitCapacity(ArrayList.java:235)
 at java.util.ArrayList.ensureCapacityInternal(ArrayList.java:227)
 at java.util.ArrayList.add(ArrayList.java:458)
 at com.jvm.oom.HeapOOM.main(HeapOOM.java:29)
 */

栈内存溢出：

package com.jvm.oom;

/**
 * 栈内存溢出
 * 该示例需要设置JVM参数：
 * -verbose:gc -XX:+PrintGCDetails -Xss2M
 *
 * 请先保存电脑上的当前工作，文档。
 * 该程序运行会导致操作系统假死，cpu使用率几乎耗尽，
 * 因此执行这段代码有较大的风险。
 *
 * Java的线程是映射到操作系统的内核线程上的。
 * -Xss:设置每个线程的堆栈大小
 * Created by chenbin on 2019\9\1 0002.
 */
public class JavaVMStackOOM {

    public void doNotStop() {
        while (true) {

        }
    }

    public static void main(String[] args) {
        JavaVMStackOOM oom = new JavaVMStackOOM();
        while (true) {
            Thread t = new Thread(new Runnable() {
                @Override
                public void run() {
                    oom.doNotStop();
                }
            });
            t.start();
        }
    }
}

栈溢出，递归调用深度过大

package com.jvm.oom;

/**
 * 栈溢出
 * 该示例需要设置JVM参数：
 * -verbose:gc -XX:+PrintGCDetails -Xss128k
 *
 * Created by chenbin on 2019\9\1 0002.
 */
public class JavaVMStackSOF {
    private int stackLength = 1;

    public void stackLeak() {
        stackLength++;
        stackLeak();
    }

    public static void main(String[] args) {
        JavaVMStackSOF oom = new JavaVMStackSOF();
        try {
            oom.stackLeak();
        } catch (Throwable e) {
            System.out.println("stack length:" + oom.stackLength);
            throw e;
        }
    }
}

/**
 * stack length:19210
 Exception in thread "main" java.lang.StackOverflowError
 at com.jvm.oom.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:15)
 at com.jvm.oom.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:15)
 at com.jvm.oom.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:15)
 at com.jvm.oom.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:15)
 at com.jvm.oom.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:15)
 at com.jvm.oom.JavaVMStackSOF.stackLeak(JavaVMStackSOF.java:15)
 */

Java方法区溢出：

package com.jvm.oom;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

/**
 * Java方法区溢出
 * 借助cglib字节码技术。
 * spring,hibernate在对类增强时都会使用到cglib.
 * 类越多越需要大的方法区来保证动态的calss可以加载入内存。
 *
 *  -verbose:gc -XX:+PrintGCDetails -XX:PermSize=128k -XX:MaxPermSize=128k
 * Created by chenbin on 2019\9\1 0002.
 */
public class JavaMethodAreaOOM {

    static class OOMObject {

    }

    public static void main(String[] args) {

        while (true) {
            Enhancer enhancer = new Enhancer();
            enhancer.setSuperclass(OOMObject.class);
            enhancer.setUseCache(false);
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    return methodProxy.invokeSuper(o,args);
                }
            });
            enhancer.create();

        }
        /**
         * 生成大量动态类:Java方法区内存溢出
         * Java.lang.OutOfMemoryError:PermGen space
         */
    }
}

运行时常量池溢出：

package com.jvm.oom;

import java.util.ArrayList;
import java.util.List;

/**
 * 运行时常量池溢出（jdk1.6版本及之前的版本才会生效）
 * 该示例需要设置JVM参数：
 * -verbose:gc -XX:+PrintGCDetails -XX:MaxPermSize=10M -XX:MaxPermSize=10M
 *
 * Jdk1.6及之前的版本，由于常量池分配在永久代，可以通过 -XX:PermSize 和 -XX:MaxPermSize限制方法区大小，从而限制常量池的大小。
 * jdk1.7开始，常量分配在Java堆中，这段代码会有堆溢出异常 -verbose:gc -Xms20M -Xmx20M  -Xmn10M -XX:+PrintGCDetails -XX:SurvivorRatio=6
 * Created by chenbin on 2019\9\2 0003.
 */
public class RuntimeConstantPoolOOM {

    public static void main(String[] args) {
        //使用list保持着常量池引用，避免Full GC 回收常量池行为
        List<String> list = new ArrayList<>();
        //10MB的PerSize在integer范围内足够产生OOM了
        int i = 0;
        while (true) {
            list.add(String.valueOf(i++));
        }
    }
}

/**
 * [Full GC (Ergonomics) Exception in thread "main" java.lang.OutOfMemoryError: GC overhead limit exceeded
 Disconnected from the target VM, address: '127.0.0.1:59980', transport: 'socket'
 at java.lang.Integer.toString(Integer.java:403)
 [PSYoungGen: 8192K->0K(9216K)] [ParOldGen: 10062K->566K(10240K)] 18254K->566K(19456K), [Metaspace: 2900K->2900K(1056768K)], 0.0069864 secs] [Times: user=0.02 sys=0.00, real=0.01 secs]
 at java.lang.String.valueOf(String.java:3099)
 at com.jvm.oom.RuntimeConstantPoolOOM.main(RuntimeConstantPoolOOM.java:23)
 */

/**
 * java.lang.OutOfMemoryError: GC overhead limit exceeded ，
 * 超出了GC开销限制。这个是JDK6新添的错误类型。是发生在GC占用大量时间为释放很小空间的时候发生的，
 * 是一种保护机制。一般是因为堆太小，导致异常的原因：没有足够的内存。
 * Sun 官方对此的定义：超过98%的时间用来做GC并且回收了不到2%的堆内存时会抛出此异常。
 */

直接内存溢出：

package com.jvm.oom;

import sun.misc.Unsafe;

import java.lang.reflect.Field;

/**
 * 直接内存溢出
 *
 *  -verbose:gc -XX:+PrintGCDetails -Xms20M -XX:MaxDirectMemorySize=10M
 * Created by chenbin on 2019\9\1 0002.
 */
public class DirectMemoryOOM {

    private static final int _1MB = 1024 * 1024;

    public static void main(String[] args) {
        Field unsafeField = Unsafe.class.getDeclaredFields()[0];
        unsafeField.setAccessible(true);
        try {
            Unsafe unsafe = (Unsafe)unsafeField.get(null);
            while (true) {
                unsafe.allocateMemory(_1MB);
            }
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        /**
         * Exception in thread "main" java.lang.OutOfMemoryError
         at sun.misc.Unsafe.allocateMemory(Native Method)
         at com.jvm.oom.DirectMemoryOOM.main(DirectMemoryOOM.java:23)
         *
         */
    }
}

String常量分配的测试：

package com.jvm.oom;

/**
 * String常量分配的测试
 * jdk1.8 String 常量分配在堆中的常量池
 * Created by chenbin on 2019\9\2 0002.
 */
public class StringTest {

    public static void main(String[] args) {
        /**
         * 两个对象（如果原来常量池中没有"string"）
         * String str2 = new String("string"); 创建实例的过程
         * 1.首先在堆中（不是常量池）创建一个指定的对象"string",并让str2引用指向该对象
         * 2.在字符串常量池中查看，是否存在内容为"string"字符串对象
         * 3.若存在，则将new出来的字符串对象与字符串常量池中的对象联系起来
         * 4.若不存在，则在字符串常量池中创建一个"string"的字符串对象，并将堆中的对象与之联系起来
         */
        String str2 = new String("string");
        /**
         * 1.首先在常量池中查找是否存在内容为"abc"字符串对象
         * 2.如果不存在则在常量池中创建"abc"，并让str引用该对象
         * 3.如果存在则直接让str引用该对象
         */
        String str1 = "string";
        String str3 = "string";

        /**
         * == 比较地址值
         * equals()比较内容
         * str2 new的对象在堆中
         * str1 所引用的字符串内容是在字符串常量池中
         * 所以str2 的地址 和 str1的地址不同
         */
        System.out.println(str1 == str2);
        /**
         * intern生成的str2所引用的字符串内容是在字符串常量池中，
         * 而通过new String方法生成的str1，
         * 该字符串对象是位于存放对象的Java堆中，二者的地址是不同的
         */
        System.out.println(str2.intern() == str2);
        /**
         * 1.首先在常量池中查找是否存在内容为"abc"字符串对象
         * 2.如果不存在则在常量池中创建"abc"，并让str引用该对象
         * 3.如果存在则直接让str引用该对象
         *   所以 str1 ,str3 指向的是同一个地址
         */
        System.out.println(str3 == str1);
    }
}

备注：本文的代码可以在git中下载地址：https://github.com/chenbin911029/mutiThread.git

代码目录在：package com.jvm.oom 中

参考文献：JVM高级特性与最佳实践（第二版）