1.JVM体系结构JVM的位置

JVM体系结构

2.类加载器双亲委派机制

package java.lang;/** * 测试自定义java.lang.String类能否运行成功 * 体会双亲委派机制 * * 类加载器逐级向上检查：app->ext->boot * 发现boot类加载器中也有String类，但是没有main方法，于是报错 * app:应用程序加载器 * ext:扩展类加载器 * boot:启动类（根）加载器 * * 检查什么？每一级类加载器能够加载的类是固定的，不能越级加载。 * boot能加载的类，app，ext就不能加载；同理，exit能加载的，app就不能加载。 * 一个形象的比喻：类，app，ext，boot分别对应平民，村长，乡长，县长。 * 村长会向乡长汇报，乡长向县长汇报。如果这个案子很特殊，应该有县长来处理，那么村长和乡长当然不能管了。 * * 通过验证“hello”是否会输出，可以知道：先加载类，再去执行main方法。 * 类是方法的载体，包括main方法，想要用方法，就得先加载类 */public class String {    public static void main(String[] args) {        System.out.println("hello");        //这一行会输出吗？        String s = "";        System.out.println(s.getClass().getClassLoader());    }}

运行结果：

错误: 在类 java.lang.String 中找不到 main 方法, 请将 main 方法定义为:   public static void main(String[] args)否则 JavaFX 应用程序类必须扩展javafx.application.Application
public class Cat {    /**     * 测试自定义普通类使用哪个类加载器     *     * 从app到boot检查是否有Cat类，发现ext和boot中都没有Cat类     * 所有直接还是用app加载器     */    public static void main(String[] args) {        System.out.println("Hello");        System.out.println(Cat.class.getClassLoader());     //运行结果：sun.misc.Launcher$AppClassLoader@18b4aac2    }}

3.沙箱安全机制4.native

native是Java的一个关键字，使用它可以调用本地方法，访问本地资源。

Thread类中的一个用法：

private native void start0();

执行到start0()时，start0()进入本地方法栈，然后调用本地方法接口JNI（Java Native Interface)，然后调用本地方法库。

5.方法区存哪些东西

  • static变量
  • final变量
  • Class对象
  • 常量池

实例变量存放在堆中。

面试题：一个实例的创建过程？

  1. 类加载，Class对象存放在方法区中。
    1. 父类静态成员
    2. 子类静态成员
    3. 父类代码块
    4. 父类构造器
    5. 子类代码块
    6. 子类构造器
  2. 实例的声明 Object obj，存放在栈中。
  3. 实例的创建 new Object()，存放在堆中。
  4. 将对象实例的地址赋给对象的引用（栈中的变量名指向堆中具体的对象）。obj = new Object();
  5. 对对象的属性赋值。
  6. 调用方法。

6.栈

特点：先进后出，后进先出

为什么main方法先执行，后结束？

进栈顺序：main(),test1(),test2()

出栈顺序：test2(),test1(),main()

为什么递归会引起栈溢出？

当调用递归出现死循环的情况时，栈溢出也就出现了。

测试代码：

package stack_;public class TestStack {    public static void main(String[] args) {        test1();    }    static void test1(){        test2();    }    static void test2(){        test1();    }}

运行结果：

Exception in thread "main" java.lang.StackOverflowErrorat stack_.TestStack.test2(TestStack.java:12)at stack_.TestStack.test1(TestStack.java:8)……此处省略1000多行（马德，typora软件都干卡死了）……at stack_.TestStack.test2(TestStack.java:12)at stack_.TestStack.test1(TestStack.java:8)Process finished with exit code 1

7.堆

堆：heap

堆中的三个区域

  • 新生区
    • 伊甸园
    • 幸存区0
    • 幸存区1
  • 养老区
  • 永久区

新生区

伊甸园：类的创建，应用，甚至消亡。

伊甸园满了之后，触发GC，有一部分被销毁，有一部分进入幸存区。幸存区0,1又会发生数据交换。

老年区

新生区满了之后，触发Full GC，进入老年区。

老年区和新生区都满了，就会发生OOM。

一般不会出现OOM，因为99%的数据都是临时的，用完就不再使用，在伊甸园或幸存区就被回收了。

永久区

JDK1.6及以前：永久代，常量池位于方法区

JDK1.7：永久代，常量池位于堆

JDK1.8及以后，永久区更名为：元空间，常量池位于元空间

内存调优

//虚拟机需要的最大内存        long max = Runtime.getRuntime().maxMemory();        //虚拟机初始化时的总内存        long original = Runtime.getRuntime().totalMemory();        System.out.println("max:" + max + "Byte," + max / 1024 / 1024 + "MB");        System.out.println("original:" + original + "Byte," + original / 1024 / 1024 + "MB");/** * 调优之前： * max / 电脑内存 ≈ 1 / 4 * original / 电脑内存 ≈ 1 / 64  *内存调优：-Xms1024m -Xmx1024m -XX:+PrintGCDetails */

运行结果：

max:1029177344Byte,981MBoriginal:1029177344Byte,981MBHeap PSYoungGen      total 305664K, used 20971K  eden space 262144K, 8% used  from space 43520K, 0% used  to   space 43520K, 0% used ParOldGen       total 699392K, used 0K  object space 699392K, 0% used Metaspace       used 3282K, capacity 4496K, committed 4864K, reserved 1056768K  class space    used 356K, capacity 388K, committed 512K, reserved 1048576KProcess finished with exit code 0

（305664K+699392K）/ 1024 = 981M

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

OOM 内存溢出案例演示

package heap_;import java.util.Random;/** * 测试堆内存溢出 */public class TestOOM {    public static void main(String[] args) {        String s = "hello";        while (true){            s +=  s + s + new Random().nextInt(999999999);        }    }}

运行结果：

Exception in thread "main" java.lang.OutOfMemoryError: Java heap spaceat java.util.Arrays.copyOf(Arrays.java:3332)at java.lang.AbstractStringBuilder.ensureCapacityInternal(AbstractStringBuilder.java:124)at java.lang.AbstractStringBuilder.append(AbstractStringBuilder.java:448)at java.lang.StringBuilder.append(StringBuilder.java:136)at heap_.TestOOM.main(TestOOM.java:9)Process finished with exit code 1

Java中的字符串可以不停的增加长度，但是JVM中的堆内存空间是有限的。

对虚拟机参数进行调整（-Xms8m -Xmx8m -XX:+PrintGCDetails），并观察运行结果。

可以看到很快就会运行结束，并报OOM错误。

出现OOM，如何解决？

  • 内存调大一点
  • 如果还是有问题，就要研究代码，是否有bug

使用Jprofiler分析内存

Jprofiler安装教程：https://www.cnblogs.com/zhangxl1016/articles/16220183.html

测试代码：

package heap_;import java.util.ArrayList;public class TestDump {    byte[] arr = new byte[1024 * 1024];     //共1MB的空间    public static void main(String[] args) {        ArrayList list = new ArrayList();        int count = 0;        try {            while (true) {                list.add(new TestDump());                count++;            }        }         //OOM要用Error来捕获        catch (Error error) {            System.out.println("count=" + count);            error.printStackTrace();        }    }}

运行结果：

java.lang.OutOfMemoryError: Java heap spaceDumping heap to java_pid3996.hprof ...Heap dump file created [7778880 bytes in 0.024 secs]count=6java.lang.OutOfMemoryError: Java heap spaceat heap_.TestDump.(TestDump.java:6)at heap_.TestDump.main(TestDump.java:13)Process finished with exit code 0

并在当前项目的根目录下生成了Jprofiler文件：

双击打开：

可以看到最上边的列表项（ArrayList）占用的内存是最高的，说明是它出了问题。

那么具体是代码中的哪一行有问题呢？

因为这个案例只有main方法一个线程，所以直接点main，然后在下方可以看到是源代码第13行出了问题。

为什么到count=6时就报错了呢？因为在第13行每加一个对象，就会增加1MB的空间，我们分配的最大空间是8MB，所以加到6的时候，就会发生内存溢出。

记得删除生成的Jprofiler文件，因为比较占用空间。

虚拟机参数

-Xms 设置初始化内存大小 默认1/64

-Xmx 设置最大分配内存 默认1/4

-XX:PrintGCDetails 打印GC垃圾回收信息

-XX:HeapDumpOnOutOfMemoryError 转储OOM异常信息

上一个案例设置为：-Xms1m -Xmx8m -XX:+HeapDumpOnOutOfMemoryError

垃圾回收哪些东西是垃圾？

不需要的，而且占了空间的对象。

在哪里回收？

堆

为什么不在栈回收？因为栈里没有垃圾，栈不存对象，只存储变量的引用和方法。

举个例子：假设堆中存的是具体的人，那么栈中存的是人的姓名。人去世之后，这个具体的对象依然存在堆中，而且占用空间，所以它需要被回收。栈里存的名字，用完了就自动出栈了，所以栈中不存在垃圾，亦无需回收。

如何回收？引用计数法

每一个对象都有一个计数器，某个对象被使用一次，相应的计数器就会加1。垃圾回收时，计数器为0的对象被回收。

缺点：当对象很多时，计数器也会占用大量的资源。

复制算法

主要针对新生区

假设当前伊甸园有两个对象：o1，o2，GC之后，o1被销毁，o2进入幸存区。幸存区有两个，要去哪个呢？哪个是空的，就去哪个。另外一个幸存区中，如果有对象，也会进入to区。然后当前的to区又变成from区，from区又变成to区。一定要保证有一个幸存区是空的，这个区就是to区。

”谁空谁是to“

一个对象在新生区经历15次（默认次数）还没有消亡，那么它会进入老年区，类似于久经沙场的老兵，活到最后就可以养老了。

这里涉及到一个JVM参数：-XX:MaxTenuringThreshold=15，默认值是15，如果这个值调到很大，那么新生区的对象会很难进入到老年区中。

  • 优点：没有内存碎片。
  • 缺点：浪费空间。
    • 总是要保证to区是空的。
    • 假设对象100%存活，to区就要面临无法容纳所有对象的情况。to区同时要面临伊甸园和form区两个方向的对象。
  • 最佳使用场景：对象存活度较低的区域—新生区。

标记压缩清除算法

第一次扫描：标记存活的对象，没被标记的就是不需要的

第二次扫描：清除没用的对象，会产生碎片

最后一次扫描：被标记的对象向一侧移动，另一侧就是被清除掉的

优点：不会增加额外的空间

缺点：扫描会浪费时间，会有内存碎片产生

优化：先进行几次标记清除，最后再统一压缩

算法比较

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

    • 复制是一个动作，清除是两个动作，压缩有三个动作

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

    • 复制和压缩都没有内存碎片

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

    • 清除和压缩都在原有空间中操作，复制算法总是要保证to区是空的

有没有最优算法呢？

没有，只有最合适的：分代收集算法

新生代：存活率低，适合复制算法。不用担心to区的空间不够。

老年代：区域大，存活率高，适合标记清除+标记压缩混合实现。碎片不是很多的时候用标记清除，碎片积累到一定程度，就需要压缩，这其中就要涉及到内存调优。