JVM

琉璃酱%

于 2021-03-22 15:45:33 发布

阅读量149

点赞数

文章标签： jvm

本文链接：https://blog.youkuaiyun.com/m0_47656773/article/details/115081758

版权

JVM

一、常问面试题：

请你谈谈你对JVM的理解? java8虚拟机和之前的变化更新?
什么是OOM，什么是栈溢出StackOverFlowError? 怎么分析?
JVM的常用调优参数有哪些?
内存快照如何抓取，怎么分析Dump文件?知道吗?
谈谈JVM中，类加载器你的认识?

二、怎么学习JVM

百度或者在Press on 上看思维导图

三、JVM的主要内容

1、JVM的位置

2、JVM的体系结构

3、JVM 内存模型

根据 JVM 规范，JVM 内存共分为虚拟机栈、堆、方法区、程序计数器、本地方法栈五个部分。

4、类加载器

（1）作用：加载 Class 文件

示例：类和对象

package jvm;

public class Car {
    
    public int age;

    public static void main(String[] args) {
        // 类是模板，对象是具体的

        Car car1 = new Car();
        Car car2 = new Car();
        Car car3 = new Car();

        System.out.println(car1.hashCode());
        System.out.println(car2.hashCode());
        System.out.println(car3.hashCode());

        Class<? extends Car> aClass1 = car1.getClass();
        Class<? extends Car> aClass2 = car2.getClass();
        Class<? extends Car> aClass3 = car3.getClass();

        System.out.println(aClass1.hashCode());
        System.out.println(aClass2.hashCode());
        System.out.println(aClass3.hashCode());

    }

}

（2）JVM中提供了三层的ClassLoader：

Bootstrap classLoader（启动类/根加载器）：主要负责加载核心的类库(java.lang.*等)，构造ExtClassLoader和APPClassLoader。
ExtClassLoader（扩展类加载器）：主要负责加载jre/lib/ext目录下的一些扩展的jar。
AppClassLoader（应用程序加载器）：主要负责加载应用程序的主函数类

（3）双亲委派机制（安全）

APP --> EXT --> BOOT

类加载器收到类加载的请求!
将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类加载器
启动加载器检查是否能够加载当前这个类，能加载就结束，使用当前的加载器，否则，抛出异常，通知子加载器进行加载
重复步骤3
Class Not Found ~
null : java 调用不到C、C++

示例1：双亲委派机制

package jvm;

public class Car {

    public int age;

    public static void main(String[] args) {
        // 类是模板，对象是具体的

        Car car1 = new Car();
        Car car2 = new Car();
        Car car3 = new Car();

        System.out.println(car1.hashCode());

        Class<? extends Car> aClass1 = car1.getClass();

        ClassLoader classLoader = aClass1.getClassLoader();
        System.out.println(classLoader); // AppClassLoader
        System.out.println(classLoader.getParent()); // ExtClassLoader  \jre\lib\ext
        System.out.println(classLoader.getParent().getParent()); // null 1.不存在 2.java程序获取不到  rt.jar

    }

}

示例2：String类

package java.lang;

public class String {

    public String toString() {
        return "hello";
    }

    public static void main(String[] args) {
        String s = new String();
        System.out.println(s.getClass().getClassLoader());
        s.toString();
        
    }
    
}

5、沙箱安全机制（了解）

组成沙箱的基本组件:

字节码校验器(bytecode verifier) : 确保Java类文件遵循Java语言规范。这样可以帮助lava程序实现内存保护。但并不是所有的类文件都会经过字节码校验，比如核心类。
类装载器(class loader) : 其中类装载器在3个方面对Java沙箱起作用
- 它防止恶意代码去干涉善意的代码; //双亲委派机制
- 它守护了被信任的类库边界;
- 它将代码归入保护域，确定了代码可以进行哪些操作。

虚拟机为不同的类加载器载入的类提供不同的命名空间，命名空间由一系列唯一的名称组成，每一个被装载的类将有一个名字，这个命名空间是由Java虚拟机为每一个类装载器维护的，它们互相之间甚至不可见。

类装载器采用的机制是双亲委派模式。

从最内层VM自带类加载器开始加载，外层恶意同名类得不到加载从而无法使用;
由于严格通过包来区分了访问域，外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效。

存取控制器（access controller) : 存取控制器可以控制核心API对操作系统的存取权限，而这个控制的策略设定，可以由用户指定。
(安全管理器(security manager)︰是核心API和操作系统之间的主要接口。实现权限控制，比存取控制器优先级高。
安全软件包(security package) : java.security下的类和扩展包下的类，允许用户为自己的应用增加新的安全特性，包括:
- 安全提供者
- 消息摘要
- 数字签名 keytools
- 加密
- 鉴别

6、Native（重点）

凡是带了native关键字的，说明java的作用范围达不到，去调用底层C语言的库！

JNl: Java Native lnterface (Java本地方法接口)

凡是带了native关键字的方法就会进入本地方法栈，其他的就是Java栈;

Native Interface本地接口

本地接口的作用是融合不同的编程语言为Java所用，它的初衷是融合C/C++程序，Java在诞生的时候是C/C++横行的时候，想要立足，必须有调用C、C++的程序，于是就在内存中专门开辟了一块区域处理标记为native的代码，它的具体做法是在Native Method Stack 中登记native方法，在( Execution Engine )执行引擎执行的时候加载Native Libraies。

目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过Java程序驱动打印机或者Java系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间通信很发达，比如可以使用Socket通信，也可以使用Web Service等等，不多做介绍!

Native Method Stack

它的具体做法是Native Method Stack 中登记native方法，在(Execution Engine )执行引擎执行的时候加载Native Libraies。【本地库】

编写一个多线程类启动

public static void main(String[] args){
    new Thread(()->{
        
    },"my thread name").start();
/*
    // native : 凡是带了native 关键字的，说明java的作用范围达不到了，会去调用底层C语言的库！
    // 会进入本地方法栈
    // 然后调用本地方法本地接口  JNI(Java Native Interface)
    // JNI作用：扩展Java的使用，融合不同的编程语言为Java所用！  最初：C、C++
    // Java诞生的时候C、C++横行，想要立足，必须要有调川Ic、C++的程
    // 它在内存区域中专门开辟了一块标记区域: Native Method Stack，登记 native 方法
    // 在最终执行的时候，通过JNI加载本地方法库中的方法

    // 使用native：Java程序驱动打印机，管理系统
    // 掌握即可，在企业级应用中较为少见
    // 调用其他接口： Socket..WebService~..http~
    private native void start0();
    */
}

点进去看start方法的源码

public synchronized void start() {
       
    if (threadStatus != 0)
        throw new IllegalThreadStateException();

    group.add(this);

    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {

        }
    }
}

// 这个Thread是一个类，这个方法定义在这里是不是很诡异！看这个关键字native;
private native void start0();

7、PC寄存器（了解）

PC 寄存器，也叫程序计数器：Program Counter Register

每个线程都有一个程序计数器，是线程私有的，就是一个指针，指向方法区中的方法字节码（用来存储指向像一条指令的地址，也即将要执行的指令代码)，在执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不计

JVM支持多个线程同时运行，每个线程都有自己的程序计数器。倘若当前执行的是 JVM 的方法，则该寄存器中保存当前执行指令的地址；倘若执行的是native 方法，则PC寄存器中为空。

8、方法区（重点）

方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义，简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间；主要用于存储类的信息、常量池、方法数据、方法代码等。方法区逻辑上属于堆的一部分，但是为了与堆进行区分，通常又叫==“非堆”==。

静态变量、常量、类信息(构造方法、接口定义)、运行时的常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关

static final Class 常量池

详细的内存分析回去看Java基础视频里的创建对象内存分析

9、栈

（1）栈和队列的区别

栈：先进后出、后进先出（类似于桶）

队列：先进先出（FIFO：First Input First Output）

喝多了吐就是栈，吃多了拉就是队列

（2）为什么main()先执行，最后结束~

main方法在栈底

（3）无限递归会导致栈溢出

package jvm;

public class Test {
    public static void main(String[] args) {
        new Test().test();

    }
    public void test(){
        a();
    }
    public void a(){
        test();
    }
}

执行结果为：

（4）注意

栈内存，主管程序的运行，生命周期和线程同步；线程结束，栈内存也就释放了。
对于栈来说，不存在垃圾回收问题。
一旦线程结束，栈就Over！
每一个线程有一个私有的栈，随着线程的创建而创建。
栈中存放8大基本数据类型、对象引用和实例的方法
栈运行原理：栈帧，每个方法都会创建一个栈帧
栈的大小可以固定也可以动态扩展。当栈调用深度大于JVM所允许的范围，即栈满了，会抛出StackOverflowError的错误
当申请不到空间时，会抛出 OutOfMemoryError

（5）栈 + 堆 + 方法区：交互关系

10、三种JVM

Sun 公司 HotSpot Java HotSpot(TM) 64-Bit Server VM (build 25.131-b11, mixed mode)
BEA JRokit
IBM J9 VM

我们学习都是：HotSpot

11、堆

（1）Heap，一个JVM只有一个堆内存，堆内存的大小是可以调节的。

（2）类加载器读取了类文件后，一般会把什么东西放到堆中?

类，方法，常量，变量~，保存我们所有引用类型的真实对象;

（3）堆中还要细分为三个区域：

新生区（伊甸园区） Young/New
养老区 old
永久区 Perm

GC垃圾回收，主要在伊甸园区和养老区

（4）OOM

堆内存是 JVM 所有线程共享的部分，在虚拟机启动的时候就已经创建。所有的对象和数组都在堆上进行分配。这部分空间可通过 GC 进行回收。当申请不到空间时，OOM（OutOfMemoryError），即堆内存满了，不够了！java.lang.OutOfMemoryError: Java heap space

模拟堆内存满了

package jvm;

import java.util.Random;

public class hello {
    public static void main(String[] args) {

        String str ="kuangshensayjava";

        while (true){
            str += str + new Random().nextInt(888888888) + new Random().nextInt(999999999);
        }
    }
}

（5）在JDK8以后，永久存储区改了个名字（元空间）

12、新生区、老年区

新生区

类：诞生和成长的地方，甚至死亡
伊甸园：所有的对象都是在伊甸园区new出来的！
幸存者区（0，1）

老年区

真相：经过研究，99%的对象都是临时对象！

13、永久区

（1）永久区的概念

这个区域常驻内存的。用来存放JDK自身携带的Class对象。Interface元数据，存储的是Java运行时的一些环境或类信息，这个区域不存在垃圾回收！关闭JVM虚拟机就会释放这个区域的内存。

（2）OOM的出现

一个启动类，加载了大量的第三方jar包。如果Tomcat部署了太多的应用，大量动态生成的反射类，不断的被加载，直到内存满，就会出现OOM；

（3）永久区的变化：

jdk1.6之前：永久代，常量池是在方法区；
jdk1.7之后：永久代，但是慢慢的退化了，去永久代，常量池在堆中
jdk1.8之后：无永久代，常量池在元空间

元空间逻辑上存在，物理上不存在

（4）JDK 8 中永久代向元空间转换的原因：

字符串存在永久代中，容易出现性能问题和内存溢出。
类及方法的信息等比较难确定其大小，因此对于永久代的大小指定比较困难，太小容易出现永久代溢出，太大则容易导致老年代溢出。
永久代会为 GC 带来不必要的复杂度，并且回收效率偏低。
Oracle 可能会将HotSpot 与 JRockit 合二为一。

14、堆内存调优

（1）解决OOM:

尝试扩大堆内存看结果，Edit Configuration
分析内存，看一下哪个地方出现了问题（用专业工具）

示例1

package jvm;

public class Demo02 {
    public static void main(String[] args) {
        // 返回虚拟机试图使用的最大内存
        long max = Runtime.getRuntime().maxMemory();  // 字节  1024 * 1024
        // 返回jvm的初始化总内存
        long total = Runtime.getRuntime().totalMemory();

        System.out.println("max="+max+"字节\t"+(max/(double)1024/1024)+"MB");
        System.out.println("total="+total+"字节\t"+(total/(double)1024/1024)+"MB");

        // 默认情况下：分配的总内存 是电脑内存的1/4，而初始化的内存：1/64
    }

    // -Xms1024m -Xmx1024m -XX:+PrintGCDetails

    // 
}

调优之前：

调优之后：

305664K（Young） + 699392K（Old） = 1,005,056k = 981.5M —> 说明元空间逻辑上存在，物理上不存在

示例2

package jvm;

import java.util.Random;

// 调优：-Xms8m -Xmx8m -XX:+PrintGCDetails
public class hello {
    public static void main(String[] args) {

        String str ="kuangshensayjava";

        while (true){
            str += str + new Random().nextInt(888888888) + new Random().nextInt(999999999);
        }
    }
}

调优之前：

调优之后：

（2）使用JPofiler工具分析OOM原因

在一个项目中，突然出现了OOM故障，那么该如何排除？研究为什么出错？

能够看到代码第几行出错：内存快照分析工具 —> MAT（eclipse最早集成的），Jprofiler
Debug，一行行分析代码！

MAT，Jprofiler 作用

分析Dump内存文件，快速定位内存泄露；
获得堆中的数据
获得大的对象
…

通过 Jprofiler 来分析Dump内存文件

package jvm;

import java.util.ArrayList;

// -Xms  设置初始化内存分配大小  1/64
// -Xmx  设置最大分配内存，默认 1/4
// -XX:+PrintGCDetails   // 打印GC垃圾回收信息
// -XX:+HeapDumpOnOutOfMemoryError   // oom DUMP

// -Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
public class Demo03 {

    byte[] array = new byte[1*1024*1024];  // 1m

    public static void main(String[] args) {
        ArrayList<Demo03> list = new ArrayList<>();
        int count = 0;
        try {
            while(true){
                list.add(new Demo03());  // 问题所在
                count = count + 1;
            }
        } catch (Error e) {
            System.out.println("count:"+count);
            e.printStackTrace();
        }
    }
}

没DUMP之前

DUMP之后，把Exception改成Error捕获了异常

15、GC

JVM 在进行GC时，并不是对这三个区域统一回收。大部分时候，回收都是新生代~

新生代
幸存区（from , to）
老年区

GC两种类：轻GC（普通的GC），重GC（全局GC）

GC题目：

JVM的内存模型和分区~详细到每个区分别放什么？
堆里面的分区有哪些？Eden，from，to，老年区，说说他们的特点！
GC的常用算法有哪些？复制算法，标记压缩算法，标记清除算法，引用计数器，怎么用的？
轻GC 和重GC 分别在什么时候发生？

16、GC 常用算法

复制算法，标记压缩算法，标记清除算法，引用计数器

引用计数器

对象C会被清除

复制算法

好处：没有内存的碎片
坏处：浪费了内存空间~：多了一半空间永远是空（to）。假设对象100%存活（极端情况）

复制算法最佳使用场景：对象存活度较低的时候：新生区

标记清除算法

优点：不需要额外的空间！
缺点：两次扫描，严重浪费时间，会产生内存碎片！

标记压缩

再优化：

标记清除压缩

先标记清除几次

再压缩

总结

内存效率：复制算法 > 标记清除算法 > 标记压缩算法（时间复杂度）

内存整齐度：复制算法 = 标记压缩算法 > 标记清除算法
内存利用率：标记压缩算法 = 标记清除算法 > 复制算法

思考一个问题：难道没有最优算法吗？

答案：没有，没有最好的算法，只有最合适的算法 -----> GC：分代收集算法

年轻代：

存活率低
复制算法！

老年代：

区域大：存活率高
标记清除算法（内存碎片不是太多）+ 标记压缩混合实现

当前商业虚拟机的垃圾收集都采用“分代收集”（Generational Collection）算法，这种算法并没有什么新的思想，只是根据对象存活周期的不同将内存划分为几块。一般是把Java堆分为新生代和老年代，这样就可以根据各个年代的特点采用最适合的收集算法。在新生代中，每次垃圾收集时都发现有大批对象死去，只有少量存活，那就选用复制算法，只需要付出少量存活对象的复制成本就可以完成。而老年代中因为对象存活率高、没有额外空间对他进行分配担保，就必须使用“标记-清理”或者“标记-整理”算法来进行回收。

在Java虚拟机分代垃圾回收机制中，应用程序可用的堆空间可以分为**年轻代*与老年代*，然后年轻代有被分为*Eden区，From区与To区*。

这里写图片描述