JVM快速入门

阅读数：次 2021-01-09

原创字数统计: 4.5k字 | 预计阅读时长≈ 16分钟

Java 程序员对 JVM 应该并不陌生，如果你没有听过，没关系今天我带你走进 JVM 的世界。程序员为什么要学习 JVM 呢，其实不懂 JVM 也可以照样写出优质的代码，但是不懂 JVM 有可能被面试官虐得体无完肤。

JVM 探究

面试常见

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

jvm 的位置

在操作系统之上，包含在 jre 里。

jvm 的体系结构

栈、本地方法栈、程序计数器不会发生gc。

jvm调优主要在堆，方法区有一小部分。

类加载器

作用：加载.class文件。

新建的对象放入堆里面，引用（地址）放到栈，其中引用指向堆里面对应的对象。

1）虚拟机自带的加载器

2）启动类（根）加载器 Bootstrap ClassLoader

3）扩展类加载器 Extension ClassLoader

4）应用程序（系统类）加载器 Application ClassLoader

自己去百度深入学习：双亲委派机制

package com.itjing;

public class Car {
    public static void main(String[] args) {
        Car car = new Car();
        Class<? extends Car> aClass = car.getClass();
        ClassLoader classLoader = aClass.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
    }
}

双亲委派机制

检查顺序从下至上，加载顺序从上到下。

如果一个类加载器需要加载类，那么首先它会把这个类请求委派给父类加载器去完成，每一层都是如此。

一直递归到顶层，当父加载器无法完成这个请求时，子类才会尝试去加载。

自己定义一个 java.lang.String

package java.lang;

public class String {

    // 双亲委派机制：安全
    // 1、APP--->EXC--->BOOT (最终执行)
    // 加载顺序从上至下

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

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

    /*
       1、类加载器收到类加载的请求
       2、将这个请求向上委托给父类加载器去完成，一直向上委托，直到启动类加载器
       3、启动类加载器检查是否能够加载当前这个类，能加载就结束，使用当前的加载器，否则抛出异常，通知子加载器进行加载
       4、重复步骤3
	*/
}

// 运行结果
/*
错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:
   public static void main(String[] args)
否则 JavaFX 应用程序类必须扩展javafx.application.Application
*/

沙箱安全机制

Java 安全模型的核心就是 Java 沙箱(sandbox) ，什么是沙箱?沙箱是一个限制程序运行的环境。沙箱机制就是将 Java 代码限定在虚拟机(JVM)特定的运行范围中，并且严格限制代码对本地系统资源访问，通过这样的措施来保证对代码的有效隔离，防止对本地系统造成破坏。沙箱主要限制系统资源访问，那系统资源包括什么? CPU、内存、文件系统、网络。不同级别的沙箱对这些资源访问的限制也可以不一样。

所有的 Java 程序运行都可以指定沙箱，可以定制安全策略。

在 Java 中将执行程序分成本地代码和远程代码两种，本地代码默认视为可信任的，而远程代码则被看作是不受信的。对于授信的本地代码,可以访问一切本地资源。而对于非授信的远程代码在早期的 Java 实现中，安全依赖于沙箱 Sandbox)机制。如下图所示 JDK1.0 安全模型

但如此严格的安全机制也给程序的功能扩展带来障碍，比如当用户希望远程代码访问本地系统的文件时候，就无法实现。因此在后续的 Java1.1 版本中，针对安全机制做了改进，增加了安全策略，允许用户指定代码对本地资源的访问权限。如下图所示 JDK1.1 安全模型

在 Java1.2 版本中，再次改进了安全机制，增加了代码签名。不论本地代码或是远程代码，都会按照用户的安全策略设定，由类加载器加载到虚拟机中权限不同的运行空间，来实现差异化的代码执行权限控制。如下图所示

当前最新的安全机制实现，则引入了域(Domain)的概念。虚拟机会把所有代码加载到不同的系统域和应用域,系统域部分专门负责与关键资源进行交互，而各个应用域部分则通过系统域的部分代理来对各种需要的资源进行访问。虚拟机中不同的受保护域(Protected Domain),对应不一样的权限(Permission)。存在于不同域中的类文件就具有了当前域的全部权限，如下图所示最新的安全模型(jdk 1.6)

控制远程代码执行的权限。

jdk1.6之后的域。

组成沙箱的基本组件

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

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

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

1.从最内层 JVM 自带类加载器开始加载,外层恶意同名类得不到加载从而无法使用;

2.由于严格通过包来区分了访问域,外层恶意的类通过内置代码也无法获得权限访问到内层类，破坏代码就自然无法生效。

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

Native

包含 native 关键字的方法，说明 java 的作用范围拿不到了，会去调用底层 c 语言的库。
会进入本地方法栈。
调用本地方法接口 JNI。
JNI 作用：扩展 java 的使用，融合不同的编程语言为 java 所用。最初：c、c++
它在内存区域中专门开辟了一块标记区域：native method stack，登记 native 方法
在最终执行的时候，通过 JNI 加载本地方法库中的方法

Native Method Stack

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

Native Interface

本地接口的作用是融合不同的编程语言为 Java 所用，它的初衷是融合 C/C++程序, Java 在诞生的时候是 C/C++横行的时候，想要立足，必须有调用 C、C++的程序，于是就在内存中专门开辟了块区域处理标记为 native 的代码，它的具体做法是在 Native Method Stack 中登记 native 方法,在( Execution Engine )执行引擎执行的时候加载 Native Libraies。目前该方法使用的越来越少了，除非是与硬件有关的应用，比如通过 Java 程序驱动打印机或者 Java 系统管理生产设备，在企业级应用中已经比较少见。因为现在的异构领域间通信很发达，比如可以使用 Socket 通信,也可以使用 Web Service 等等，不多做介绍！

package com.itjing;

public class Demo {
    public static void main(String[] args) {
        new Thread(()->{

        },"mythread").start();
    }

    // native：凡是带了 native 关键字的，说明java的作用范围达不到了，会去调用底层C语言的库！
    // 会进入本地方法栈，调用本地方法接口 JNI
    // JNI作用：扩展java的使用，融合不同的编程语言为java所用！  最初：C、C++
    // java诞生的时候 C、C++ 横行，想要立足，必须要有调用C、C++的程序
    // 它在内存区域中专门开辟了一块标记区域：native method stack，登记native方法
    // 在最终执行的时候，通过JNI加载本地方法库中的方法
    // 常用的本地方法：  System.currentTimeMillis();  // public static native long currentTimeMillis();
    private native void start0();
}

PC 寄存器

线程私有，保证线程顺序。

程序计数器: Program Counter Register

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

方法区

方法区 Method Area，存储内容：static、final、.class、常量池

方法区是被所有线程共享,所有字段和方法字节码，以及一些特殊方法，如构造函数,接口代码也在此定义,简单说，所有定义的方法的信息都保存在该区域，此区域属于共享区间；

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

类实例化后：

栈

一旦线程结束，栈就 over 了。

存储：8 大基本类型 + 对象引用 + 实例的方法

栈：数据结构

程序 = 数据结构 + 算法

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

栈：先进后出

桶：后进先出

队列：先进先出( FIFO : First Input First Output ) ，喝多了吐就是栈，吃多了拉就是队列

栈：栈内存，主管程序的运行，生命周期和线程同步；线程结束，栈内存也就是释放，对于栈来说，不存在垃圾回收问题，一旦线程结束，栈就 Over！

栈内存中：8大基本类型+对象引用+实例的方法

栈运行原理：栈帧

栈满了：StackOverflowError

栈、堆、方法区交互关系

栈帧图解：

栈底部子帧指向上一个栈的方法，上一个栈的父帧指向栈底部方法

多百度查看资料，多看视频学习！

三种 JVM

Sun 公司 HotSpot （Java Hotspot™ 64-Bit Server VM (build 25.181-b13,mixed mode) ）
BEA JRockit
IBM J9VM

我们学习都是： Hotspot

堆

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

类加载器读取了类文件后，一般会把什么东西放到堆中？类, 方法，常量,变量~，保存我们所有引用类型的真实对象；

堆内存中还要细分为三个区域：

新生区(伊甸园区) Young/New
养老区 old
永久区 Perm

堆内存详细划分：

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

假设内存满了，OOM（Out Of Memory），堆内存不够！java.lang.OutOfMemoryError:Java heap space

永久存储区里存放的都是 Java 自带的，例如 lang 包中的类，如果不存在这些，Java 就跑不起来了

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

堆内存溢出：

新生区、老年区

新生区

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

轻 GC 和重 GC

伊甸园满了就触发轻 GC，经过轻 GC 存活下来的就到了幸存者区，幸存者区满之后意味着新生区也满了，则触发重 GC，经过重 GC 之后存活下来的就到了养老区。

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

永久区

java8 中，取消永久代，方法存放于元空间（metaspace），元空间任然与堆不相连，但与堆共享物理内存，逻辑上可认为在堆中

1.8 之后元空间在本地内存，是方法区的实现而已，方法区和元空间都和堆没关系

当新生代经历15次轻GC后还存在引用的，则被转移到老年代

元空间使用的是直接内存，与新生代和老年代分开。

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

●jdk1.6 之前：永久代，常量池是在方法区；

●jdk1.7：永久代，但是慢慢的退化了，去永久代，常量池在堆中

●jdk1.8 之后：无永久代，常量池在元空间

元空间：逻辑上存在，物理上不存在 (因为存储在本地磁盘内) 所以最后并不算在 JVM 虚拟机内存中

堆内存调优

// 发生了OOM
// 1、尝试扩大堆内存看结果
// 2、分析内存，看一下哪个地方出现了问题（专业工具）

// 给虚拟机设置参数
-Xms1024m -Xmx1024m -XX:+PrintGCDetails

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

能够看到代码第几行出错：内存快照分析工具，MAT，Jprofiler
Dubug，一行行分析代码！

MAT, Jprofiler作用

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

MAT是eclipse集成使用在这里不学

Jprofile 使用

1、在 idea 中安装 jprofile 插件，在 idea 的插件里面搜索安装

2、联网下载安装 jprofile 客户端：百度搜索 jprofile 下载

3、在 idea 设置的 tools 下放入 jprofile 添加 jprofile.exe 所在路径

4、编写能导致堆内存溢出的程序

5、在 idea 中 VM 参数中写参数 -Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

6、运行程序后，会生成对应的文件，在 jprofile 客户端中打开它找到错误告诉哪个位置报错

命令参数详解

-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError
-Xms // 设置初始化内存分配大小/164
-Xmx // 设置最大分配内存，默以1/4
-XX: +PrintGCDetails  // 打印GC垃圾回收信息
-XX: +HeapDumpOnOutOfMemoryError // oom DUMP
// 如果想要dump其他异常或错误
-XX: +HeapDumpOn//加上对应的名称

GC（垃圾回收）

GC 的作用区

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

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

GC 两种类：轻 GC (普通的 GC)，重 GC (全局 GC)

GC 常见面试题目

JVM的内存模型和分区，详细到每个区放什么?

堆里面的分区有哪些？说说他们的特点

Eden，from，to，老年区

GC的算法有哪些?

标记清除算法，标记整理算法，复制算法，分代收集算法，引用计数法应该与可达性分析归为一类

轻GC和重GC分别在什么时候发生？

引用计数法

记录每个对象的引用次数，长时间没有被引用的对象就被清除掉。很少使用了，并不高效

复制算法

好处：没有内存碎片

坏处：浪费内存空间，多了一半 to 空间永远是空的。

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

标记清除算法

优点：不需要额外的空间。

缺点：两次扫描，严重浪费时间，会产生内存碎片。

标记压缩

标记清除算法再优化

标记 -> 清除 -> 压缩

标记清除压缩

先标记清除几次，再压缩

总结

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

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

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

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

答案：没有，没有最好的算法，只有最合适的算法—–>GC：分代收集算法，自己去百度学习

年轻代：

存活率低
复制算法

老年代：

区域大，存活率高
标记清除（内存碎片不是太多） + 标记压缩或者实现

学习JVM，一定要深究，必须要花时间学，多看面试题，以及《深入理解JVM》，要掌握方法

JMM

Java Memory Model：java 内存模型

它是干嘛的？

根据官方学习，其他人的博客，对应的视频学习

持续更新中！

本文作者： LiJing
发布时间： 2021-01-09
最后更新： 2024-06-24
本文标题： JVM快速入门
本文链接： https://blog-yilia.xiaojingge.com/posts/cb984f9a.html
版权声明： 本作品采用 CC BY-NC-SA 4.0 许可协议进行许可。转载请注明出处！