JVM初探
- 请你谈谈你对JVM的理解？Java8虚拟机和之前的变化更新？
- 什么是OOM，什么是StackOverFlowError？怎么分析？
- JVM的常用调优参数有哪些？
- 内存快照如何抓取，怎么分析Dump文件？
- 谈谈JVM中，类加载器的认识？
- JVM的位置
- JVM的体系结构
-
类加载器
作用：加载 Class 文件
public class Car {
public int age;
public static void main(String[] args) {
// 类是模板，对象是具体的
Car car1 = new Car();
Car car2 = new Car();
Car car3 = new Car();
car1.age = 1;
car2.age = 2;
car3.age = 3;
System.out.println(car1.hashCode()); // 1735600054
System.out.println(car2.hashCode()); // 21685669
System.out.println(car3.hashCode()); // 2133927002
Class<? extends Car> aClass1 = car1.getClass();
Class<? extends Car> aClass2 = car2.getClass();
Class<? extends Car> aClass3 = car3.getClass();
System.out.println(aClass1.hashCode()); // 356573597
System.out.println(aClass2.hashCode()); // 356573597
System.out.println(aClass3.hashCode()); // 356573597
}
}
-
虚拟机自带的加载器
-
启动类（根）加载器
-
扩展类加载器
-
应用程序（系统类）加载器
-
双亲委派机制
package java.lang; public class String { // 双亲委派机制：保证安全 // 1.APP --> EXT --> BOOT（最终执行） // BOOT // EXT // APP public String toString() { return "Hello"; } public static void main(String[] args) { String s = new String(); System.out.println(s.getClass().getClassLoader()); s.toString(); /* 错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为: public static void main(String[] args) 否则 JavaFX 应用程序类必须扩展javafx.application.Application */ } /* 1.类加载器收到类加载的请求 2.将这个请求向上委托给父类加载器去完成，一直向上委托，知道启动类加载器 3.启动加载器检查是否能够加载当前这个类，能够加载就结束，使用当前的加载器，否则，抛出异常，通知子加载器进行加载 4.重复步骤 3 Class Not Found ~ null ： java调用不到~C、C++ Java = C++-- */ } -
沙箱安全机制
-
Native
它的具体做法是 Native Method Stack中登记 native 方法，在（Execution Engine）执行引擎执行的时候加载Native Libraies。【本地库】
package com.won; public class Demo { public static void main(String[] args) { new Thread(()->{ }).start(); } // native：凡是带了native 关键字的，说明java的作用范围达不到了，回去调用底层C语言的库 // 会进入本地方法栈 // 调用本地方法接口 JNI // JNI作用：扩展Java的使用，融合不同的编程语言为Java所用！ 最初：C、C++ // Java诞生的时候，C、C++ 横行，想要立足，必须要有调用C、C++ 的程序 // 它在内存区域中专门开辟了一块标记区域：Native Method Stack，登记 native 方法 // 在最终执行的时候，通过JNI 加载本地方法库中的方法。 // Java程序驱动打印机，管理系统，掌握即可，在企业级应用中较为少见！ private native void start0(); // 调用其他接口：Socket、WebService、HTTP } -
PC寄存器
程序计数器：Program Counter Register
每一个线程都有一个程序计数器，是线程私有的，就是一个指针，指向方法区中的方法字节码（用来存储指向下一条指令的地址，也即将要执行的指令代码），在执行引擎读取下一条指令，是一个非常小的内存空间，几乎可以忽略不计。
-
方法区
Method Area 方法区
方法区是被所有线程共享，所有字段和方法字节码，以及一些特殊方法，如构造函数，接口代码也在此定义，简单说，所有定义的方法的信息都保存在该区域，此区域属于共享空间；
静态变量、常量、类信息（构造方法、接口定义）、运行时常量池存在方法区中，但是实例变量存在堆内存中，和方法区无关。
static， final， Class，常量池
-
栈
栈：数据结构
程序 = 数据结构 + 算法：持续学习
程序 = 框架 + 业务逻辑：吃饭
栈：栈内存，主管程序的运行，生命周期和线程同步；
线程结束，栈内存也就释放了，对于栈来说，不存在垃圾回收问题。
一旦线程结束，栈就Over！
栈：8大基本类型 + 对象引用 + 实例的方法
栈运行原理：栈帧
栈满了：java.lang.StackOverflowError
栈 + 堆 + 方法区：交互关系
-
三种JVM
- Sun公司
Java HotSpot(TM) 64-Bit Server VM (build 25.201-b09, mixed mode) - BEA
JRockit - IBＭ
J9 VM
- Sun公司
-
堆
Heap，一个JVM只有一个堆内存，堆内存的大小是可以调节的。
类加载器读取了类文件后，一般会把什么东西放到堆中呢？ 类，方法，常量，变量~ 保存我们所有引用类型的真实对象
堆内存中还要细分为三个区域：
- 新生区（伊甸园区）
- 养老区 old
- 永久区 perm
GC 垃圾回收，主要是在伊甸园区和养老区
假设内存满了，OOM，堆内存不够！java.lang.OutOfMemoryError: Java heap space
在JDK8以后，永久存储区改了名字（元空间）
-
新生区、老年区
- 类：诞生 和 成长的地方，甚至死亡
- 伊甸园区，所有的对象都是在伊甸园区 new 出来的！
- 幸存者区（0，1）
-
永久区
这个区域常驻内存的，用来存放JDK自身携带的Class对象。Interface元数据，存储的是Java运行时的一些环境或类信息，这个区域不存在垃圾回收！关闭VM虚拟机就会释放这个区域的内存~
一个启动类加载了大量的第三方jar包。Tomcat部署了太多的应用，大量动态生成反射类，不断的被加载，直到内存满，就会出现OOM；
- JDK 1.6 之前：永久代，常量池是在方法区；
- JDK 1.7 ：永久代，但是慢慢的退化了，
去永久代，常量池在堆中 - JDK 1.8 之后：无永久代，常量池在元空间
package com.won;
public class Demo02 {
public static void main(String[] args) {
// 返回虚拟机试图使用的最大内存
long max = Runtime.getRuntime().maxMemory(); // 字节
// 返回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");
// OOM:
// 1.尝试扩大堆内存看结果
// 2.分析内存，看一下哪个地方出现了问题（专业工具）
// -Xms1024m -Xmx1024m -XX:+PrintGCDetails
/**
* System.out.println("max = " + max + "字节\t" + (max/(double) 1024/1024) + "MB"); // max = 1029177344字节 981.5MB
* System.out.println("total = " + total + "字节\t" + (total/(double) 1024/1024) + "MB"); // total = 1029177344字节 981.5MB
*
Heap
PSYoungGen total 305664K, used 20971K [0x00000000eab00000, 0x0000000100000000, 0x0000000100000000)
eden space 262144K, 8% used [0x00000000eab00000,0x00000000ebf7afb8,0x00000000fab00000)
from space 43520K, 0% used [0x00000000fd580000,0x00000000fd580000,0x0000000100000000)
to space 43520K, 0% used [0x00000000fab00000,0x00000000fab00000,0x00000000fd580000)
ParOldGen total 699392K, used 0K [0x00000000c0000000, 0x00000000eab00000, 0x00000000eab00000)
object space 699392K, 0% used [0x00000000c0000000,0x00000000c0000000,0x00000000eab00000)
Metaspace used 3134K, capacity 4496K, committed 4864K, reserved 1056768K
class space used 338K, capacity 388K, committed 512K, reserved 1048576K
*
* // 305664K + 699392K = 1,005,056K = 981.5 MB
*/
//System.out.println("max = " + max + "字节\t" + (max/(double) 1024/1024/1024) + "MB");
//System.out.println("total = " + total + "字节\t" + (total/(double) 1024/1024/1024) + "MB");
// 默认情况下：分配的总内存 是电脑内存的 1/4，而初始化的内存是 1/64
// 15.9 GB笔记本内存
// 3.54 GB Runtime.getRuntime().maxMemory()
// 0.24 GB Runtime.getRuntime().totalMemory()
}
}
结论：Metaspace（元空间）逻辑上存在，物理上不存在
在一个项目中，突然出现OOM故障，如何排除？研究为什么出错~
- 能够看到代码第几行出错：内存快照分析工具，MAT，Jprofiler
- DEBUG，一行行分析代码！
MAT，Jprofiler作用：
- 分析Dump内存文件，快速定位内存泄露
- 获得堆中的数据
- 获得大的对象
- ……
package com.won;
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();
}
}
}
-
堆内存调优
-
GC
JVM在进行GC时，并不是对这三个区域统一回收。大部分时候，回收都是新生代~
- 新生代
- 幸存区（from，to）
- 老年区
GC两种类型：轻GC（普通的GC），重GC（全局GC）
GC题目：
- JVM的内存模型和分区？详细到每个区放什么？
- 堆里面的分区有哪些？Eden，from，to，老年区，说说他们的特点！
- GC的算法有哪些？标记清除法，标记压缩，复制算法，引用计数法，怎么用的？
- 轻GC和重GC分别在什么时候发生？
引用计数法：
复制算法
-
好处：没有内存的碎片
-
坏处：浪费了内存空间~多了一般空间永远是空to。假设对象100%存货（极端情况）
复制算法最佳使用场景：对象存活度较低的时候；新生区！
标记清除算法
- 优点：不需要额外的空间！
- 缺点：两次扫描，严重浪费时间，会产生内存碎片。
标记压缩
再优化：
总结
内存效率：复制算法 > 标记清除算法 > 标记压缩算法（时间复杂度）
内存整齐度：复制算法 = 标记清除算法 > 标记压缩算法
内存利用率：标记压缩算法 = 标记清除算法 > 复制算法
思考一个问题：有没有一个最优算法？
答案：没有，没有最好的算法，只有最合适的算法 ----> GC：分代收集算法
年轻代：
- 存活率低
- 复制算法
老年代：
- 区域大：存活率高
- 标记清除（内存碎片不是太多） + 标记压缩混合 实现
- JMM
Java Memory Model
- 总结
扫一扫
957
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
