学习JVM---入门

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.StackOverflowError
	at 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,981MB
original:1029177344Byte,981MB
Heap
 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 1048576K

Process 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 space
	at 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<TestDump> 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 space
Dumping heap to java_pid3996.hprof ...
Heap dump file created [7778880 bytes in 0.024 secs]
count=6
java.lang.OutOfMemoryError: Java heap space
	at heap_.TestDump.<init>(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区的空间不够。

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