JVM虚拟机 - 基础篇

一、初始JVM

1. JVM是什么

2. JVM的三大核心功能是什么？

3. 常见的JVM虚拟机有哪些？

二、字节码文件详解

1. Java虚拟机的组成

2. 字节码文件的组成

（1）基本信息

Magic魔数

主副版本号

（2）常量池

（3）字段

（4）方法

操作数栈是用来存放临时数据的内容，是一个栈式的结构，先进后出。

局部变量表是存放方法中的局部变量，包含方法的参数、方法中定义的局部变量，在编译期就已经可以确定方法有多少个局部变量。

1、iconst_0，将常量0放入操作数栈。此时栈上只有0。

2、istore_1会从操作数栈中，将栈顶的元素弹出来，此时0会被弹出，放入局部变量表的1号位置。局部变量表中的1号位置，在编译时就已经确定是局部变量i使用的位置。完成了对局部变量i的赋值操作。

3、iload_1将局部变量表1号位置的数据放入操作数栈中，此时栈中会放入0。

4、iconst_1会将常量1放入操作数栈中。

5、iadd会将操作数栈顶部的两个数据相加，现在操作数栈上有两个数0和1，相加之后结果为1放入操作数栈中，此时栈上只有一个数也就是相加的结果1。

6、istore_2从操作数栈中将1弹出，并放入局部变量表的2号位置，2号位置是j在使用。完成了对局部变量j的赋值操作。

7、return语句执行，方法结束并返回。

同理，同学们可以自行分析下i++和++i的字节码指令执行的步骤。

i++的字节码指令如下，其中iinc 1 by 1指令指的是将局部变量表1号位置增加1，其实就实现了i++的操作。

而++i只是对两个字节码指令的顺序进行了更改：

（5）属性

3. 类的生命周期

加载 -> 连接（验证、准备、解析） -> 初始化 -> 使用 -> 卸载

（1）加载阶段

（2）连接阶段

（2-1）验证

（2-2）准备

（2-3）解析

（3）初始化

4. 类加载器

（1）类加载器的分类

（2）双亲委派机制

向上查找是否加载过

向下尝试加载

面试题 - 类的双亲委派机制是什么？

（3）打破双亲委派机制

（3-1）自定义类加载器

自定义类加载器默认的父类加载器：应用程序类加载器

package classloader.broken;//package com.itheima.jvm.chapter02.classloader.broken;

import org.apache.commons.io.IOUtils;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.nio.charset.StandardCharsets;
import java.security.ProtectionDomain;
import java.util.regex.Matcher;

/**
 * 打破双亲委派机制 - 自定义类加载器
 */

public class BreakClassLoader1 extends ClassLoader {

    private String basePath;
    private final static String FILE_EXT = ".class";

    //设置加载目录
    public void setBasePath(String basePath) {
        this.basePath = basePath;
    }

    //使用commons io 从指定目录下加载文件
    private byte[] loadClassData(String name)  {
        try {
            String tempName = name.replaceAll("\\.", Matcher.quoteReplacement(File.separator));
            FileInputStream fis = new FileInputStream(basePath + tempName + FILE_EXT);
            try {
                return IOUtils.toByteArray(fis);
            } finally {
                IOUtils.closeQuietly(fis);
            }

        } catch (Exception e) {
            System.out.println("自定义类加载器加载失败，错误原因：" + e.getMessage());
            return null;
        }
    }

    //重写loadClass方法
    @Override
    public Class<?> loadClass(String name) throws ClassNotFoundException {
        //如果是java包下，还是走双亲委派机制
        if(name.startsWith("java.")){
            return super.loadClass(name);
        }
        //从磁盘中指定目录下加载
        byte[] data = loadClassData(name);
        //调用虚拟机底层方法，方法区和堆区创建对象
        return defineClass(name, data, 0, data.length);
    }

    public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException, IOException {
        //第一个自定义类加载器对象
        BreakClassLoader1 classLoader1 = new BreakClassLoader1();
        classLoader1.setBasePath("D:\\lib\\");

        Class<?> clazz1 = classLoader1.loadClass("com.itheima.my.A");
         //第二个自定义类加载器对象
        BreakClassLoader1 classLoader2 = new BreakClassLoader1();
        classLoader2.setBasePath("D:\\lib\\");

        Class<?> clazz2 = classLoader2.loadClass("com.itheima.my.A");

        System.out.println(clazz1 == clazz2);

        Thread.currentThread().setContextClassLoader(classLoader1);

        System.out.println(Thread.currentThread().getContextClassLoader());

        System.in.read();
     }
}

（3-2）线程上下文类加载器

总结：

（4）JDK8之后的类加载器

（5）总结

1. 类加载器的作用是什么？

2. 有几种类加载器？

3. 什么是双亲委派机制？

4. 怎么打破双亲委派机制？

三、JVM的内存区域

运行时数据区 - 总览

1. 程序计数器

2. 栈

（1）Java虚拟机栈

栈帧的组成

操作数栈

帧数据

帧数据主要包含动态链接、方法出口、异常表的引用。

动态链接：

方法出口：

异常表：

栈内存溢出：

（2）本地方法栈

3. 堆

4. 方法区

（1）类的元信息

（2）运行时常量池

（3）字符串常量池

字符串常量池存放在Java堆内存（heap）中。

静态变量存储在哪里？

5. 直接内存

总结：

1. 运行时数据区分为哪几个部分，每一部分的作用是什么？

程序计数器：每个线程会通过程序计数器记录当前要执行的字节码指令的地址，程序计数器可以控制程序指令的进行，实现分支、跳转、异常等逻辑。

Java虚拟机栈：采用栈的数据结构赖管理方法调用中的基本数据（局部变量、操作数、帧数据），每一个方法的调用使用一个栈帧来保存。

本地方法栈：本地方法栈存储的是native本地方法的栈帧。

堆：存放中的是创建出来的对象，这也是最容易产生内存溢出的位置。

方法区：主要存放的是类的元信息，同时还保存了常量池。

2. 不同JDK版本之间运行时数据区域的区别是什么？JDK6

（在JDK8中，类的元信息和运行时常量池存放在元空间中，使用本地内存。字符串常量池存放在Java堆内存中。）

四、JVM的垃圾回收

C/C++的内存管理

Java的内存管理

1. 方法区的回收

2. 堆回收

（1）引用计数法和可达性分析法

如何判断堆上的对象可以回收？

引用计数法

可达性分析算法

哪些对象被称之为GC Root对象呢？

查看GC Root对象

（2）五种对象引用

软引用

代码：

/**
 * 软引用案例3 - 引用队列使用
 */
public class SoftReferenceDemo3 {

    public static void main(String[] args) throws IOException {

        ArrayList<SoftReference> softReferences = new ArrayList<>();
        ReferenceQueue<byte[]> queues = new ReferenceQueue<byte[]>();
        for (int i = 0; i < 10; i++) {
            byte[] bytes = new byte[1024 * 1024 * 100];
            SoftReference studentRef = new SoftReference<byte[]>(bytes,queues);
            softReferences.add(studentRef);
        }

        SoftReference<byte[]> ref = null;
        int count = 0;
        while ((ref = (SoftReference<byte[]>) queues.poll()) != null) {
            count++;
        }
        System.out.println(count);

    }
}

代码：

package chapter04.soft;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.util.HashMap;
import java.util.Map;
/**
 * 软引用案例4 - 学生信息的缓存
 */
public class StudentCache {

    private static StudentCache cache = new StudentCache();

    public static void main(String[] args) {
        for (int i = 0; ; i++) {
            StudentCache.getInstance().cacheStudent(new Student(i, String.valueOf(i)));
        }
    }

    private Map<Integer, StudentRef> StudentRefs;// 用于Cache内容的存储
    private ReferenceQueue<Student> q;// 垃圾Reference的队列

    // 继承SoftReference，使得每一个实例都具有可识别的标识。
    // 并且该标识与其在HashMap内的key相同。
    private class StudentRef extends SoftReference<Student> {
        private Integer _key = null;

        public StudentRef(Student em, ReferenceQueue<Student> q) {
            super(em, q);
            _key = em.getId();
        }
    }

    // 构建一个缓存器实例
    private StudentCache() {
        StudentRefs = new HashMap<Integer, StudentRef>();
        q = new ReferenceQueue<Student>();
    }

    // 取得缓存器实例
    public static StudentCache getInstance() {
        return cache;
    }

    // 以软引用的方式对一个Student对象的实例进行引用并保存该引用
    private void cacheStudent(Student em) {
        cleanCache();// 清除垃圾引用
        StudentRef ref = new StudentRef(em, q);
        StudentRefs.put(em.getId(), ref);
        System.out.println(StudentRefs.size());
    }

    // 依据所指定的ID号，重新获取相应Student对象的实例
    public Student getStudent(Integer id) {
        Student em = null;
// 缓存中是否有该Student实例的软引用，如果有，从软引用中取得。
        if (StudentRefs.containsKey(id)) {
            StudentRef ref = StudentRefs.get(id);
            em = ref.get();
        }
// 如果没有软引用，或者从软引用中得到的实例是null，重新构建一个实例，
// 并保存对这个新建实例的软引用
        if (em == null) {
            em = new Student(id, String.valueOf(id));
            System.out.println("Retrieve From StudentInfoCenter. ID=" + id);
            this.cacheStudent(em);
        }
        return em;
    }

    // 清除那些所软引用的Student对象已经被回收的StudentRef对象
    private void cleanCache() {
        StudentRef ref = null;
        while ((ref = (StudentRef) q.poll()) != null) {
            StudentRefs.remove(ref._key);
        }
    }

//    // 清除Cache内的全部内容
//    public void clearCache() {
//        cleanCache();
//        StudentRefs.clear();
//        //System.gc();
//        //System.runFinalization();
//    }
}

class Student {
    int id;
    String name;

    public Student(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

弱引用

package chapter04.weak;

import java.io.IOException;
import java.lang.ref.WeakReference;

/**
 * 弱引用案例 - 基本使用
 */
public class WeakReferenceDemo2 {
    public static void main(String[] args) throws IOException {

        byte[] bytes = new byte[1024 * 1024 * 100];
        WeakReference<byte[]> weakReference = new WeakReference<byte[]>(bytes);
        bytes = null;
        System.out.println(weakReference.get());

        System.gc();

        System.out.println(weakReference.get());
    }
}

虚引用和终结器引用

终结器引用案例

package chapter04.finalreference;

/**
 * 终结器引用案例
 */
public class FinalizeReferenceDemo {
    public static FinalizeReferenceDemo reference = null;

    public void alive() {
        System.out.println("当前对象还存活");
    }

    @Override
    protected void finalize() throws Throwable {
        try{
            System.out.println("finalize()执行了...");
            //设置强引用自救
            reference = this;
        }finally {
            super.finalize();
        }
    }

    public static void main(String[] args) throws Throwable {
        reference = new FinalizeReferenceDemo();
       test();
       test();
    }

    private static void test() throws InterruptedException {
        reference = null;
        //回收对象
        System.gc();
        //执行finalize方法的优先级比较低，休眠500ms等待一下
        Thread.sleep(500);
        if (reference != null) {
            reference.alive();
        } else {
            System.out.println("对象已被回收");
        }
    }
}

（3）垃圾回收算法

垃圾回收算法的评价标准

标记—清除算法

复制算法

标记—整理算法

分代垃圾回收算法

为什么分代GC算法要把堆分成年轻代和老年代？

（4）垃圾回收器

①年轻代 - Serial垃圾回收器 -> 复制算法

老年代 - SerialOld垃圾回收器 -> 标记整理算法

②年轻代 - ParNew垃圾回收器 -> 复制算法

老年代 - CMS(Concurrent Mark Sweep)垃圾回收器 -> 标记清除算法

③年轻代 - Parallel Scavenge垃圾回收器 -> 复制算法

老年代 - Paralell Old垃圾回收器 -> 标记整理算法

④G1垃圾回收器

总结：

1. Java中有哪几块内存需要进行垃圾回收？

线程不共享：跟随线程的生命周期随着线程回收而回收；

方法区：一般不需要回收，JSP等技术会通过回收类加载器去回收方法区中的类

堆：由垃圾回收器进行回收

2. 有哪几种常见的引用类型？

3. 有哪几种常见的垃圾回收算法？

4. 常见的垃圾回收器有哪些？