Java底层知识:JVM

JAVA底层知识:JVM

一 谈谈你对Java的理解

  • 平台无关性,即一次编译,到处运行
  • GC,垃圾回收机制,不必像C++那样手动释放内存了
  • 语言特性:泛型、反射、Lambda表达式
  • 面向对象:封装、继承、多态
  • 类库、Java本身自带的一些集合和一些并发库,网络库、IO/NIO
  • 异常处理

二 Compile Once,Run Anywhere如何实现

  • 编译时

javac编译,生成字节码文件,JVM解析,转换成特定平台的执行指令

img

Java源码首先被变异成字节码文件,再有不同平台的JVM进行解析,Java语言在不同的平台上运行时不需要进行重新编译,Java虚拟机在执行字节码的时候,把字节码转换成具体平台上的机器指令。

如何查看java字节码: javap

2.1 为什么JVM不直接将源码解析成机器码去执行

  • 准备工作: 每次执行都需要各种检查
  • 兼容性:也可以将别的语言解析成字节码
  • 首先这样做有两点好处:可以节省大量的准备工作,提升效率,其次可以提升兼容性;

三 JVM如何加载.class文件

  • 运行时

首先这个问题我们需要弄明白Java虚拟机,虚拟机是跑在内存中的,虚拟机核心的有两点:

内存模型,②GC;

先来看一下JVM的架构图

img

  1. Class Loader : 负责加载符合格式的.class文件;
  2. Execution Engine : 对命令进行解析;
  3. Native Interface : 融合不同开发语言的原生库为Java所用;
  4. Runtime Data Area : Java内存空间模型;

四 谈谈反射

4.1 反射的概念

Java反射机制是在运行状态中,对于任意一个类,都能够知道这个类的所有属性和方法;对于任意一个对象,都能够调用它的任意方法和属性;这种动态获取信息以及动态调用对象的功能称为Java语言的反射机制;

4.2 写一个反射的例子

public class Robot {
    //私有name  getDeclaredField()
    private String name;
    //公用方法 getMethod()
    public void sayHi(String helloSentence){
        System.out.println(helloSentence+" "+name);
    }
    //私有方法 getDeclaredMethod()
    private String throwHello(String tag){
        return "hello " + tag;
    }
}
public class ReflectSample {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException, NoSuchFieldException {
        Class<?> rc = Class.forName("com.interview.javabasic.reflect.Robot");
        Robot r =(Robot) rc.newInstance();
        System.out.println("Class name is: " + rc.getName());

        //private方法
        //getDeclaredMethod:获取当前类的所有声明的方法,包括public、protected和private修饰的方法。
        //需要注意的是,这些方法一定是在当前类中声明的,从父类中继承的不算,实现接口的方法由于有声明所以包括在内。
        Method getHello = rc.getDeclaredMethod("throwHello", String.class);
        getHello.setAccessible(true);//setAccessible(true)取消了Java的权限控制检查
        Object str = getHello.invoke(r,"zpf");
        System.out.println("getHello result is: " + str);

        //public方法
        //getMethod:获取当前类和父类的所有public的方法。
        // 这里的父类,指的是继承层次中的所有父类。比如说,A继承B,B继承C,那么B和C都属于A的父类。
        Method sayHi = rc.getMethod("sayHi", String.class);
        sayHi.invoke(r,"Welcome");

        //getDeclaredFiled 仅能获取类本身的属性成员(包括私有、共有、保护)
        //getField 仅能获取类(及其父类可以自己测试) public属性成员
        Field name = rc.getDeclaredField("name");
        name.setAccessible(true);
        name.set(r,"Alice");
        sayHi.invoke(r,"Welcome");

    }
}

4.3 类从编译到执行的工程

  1. 编译器将.ava源文件编译成Class文件;
  2. ClassLoader将字节码转换成JVM中的Class< T >对象;
  3. JVM利用Class< T >对象实例化为T对象;

五 谈谈ClassLoader类加载器

5.1 ClassLoader类加载器

ClassLoader在Java中有着非常重要的作用,它主要工作在Class装载的加载阶段,其主要作用是从系统外部获得Class二进制数据流.它是Java的核心组件,所有的Class都是由ClassLoader进行加载的,ClassLoader负责通过将Class文件里的二进制数据流装载进系统,然后交给Java虚拟机进行连接/初始化等操作.

5.2 ClassLoader的种类

BootStrapClassLoader : C++编写, 加载核心库Java.*;

ExtClassLoader : Java编写,加载扩展库javax.*;

AppClassLoader : Java编写,加载程序所在目录;

自定义ClassLoader : Java编写,定制化加载;

5.3 自定义ClassLoader的实现

  1. 重写findClass() : 这个函数是用来寻找Class文件的;

    protected Class<?> findClass(String name) throws ClassNotFoundException {
        throw new ClassNotFoundException(name);
    }
    
  2. 重写defineClass() : 解析字节码返回对象;

    protected final Class<?> defineClass(byte[] b, int off, int len)
        throws ClassFormatError
    {
        return defineClass(null, b, off, len, null);
    }
    
  3. 自定义ClassLoader

    public class MyClassLoader extends ClassLoader{
        private String path;
        private String classLoadName;
    
        public MyClassLoader(String path, String classLoadName){
            this.path = path;
            this.classLoadName = classLoadName;
        }
    
        //用于寻找类文件
        @Override
        public Class findClass(String name){
            byte[] b = loadClassData(name);
            return defineClass(name,b,0,b.length);
        }
    
        //用于加载类文件
        private byte[] loadClassData(String name) {
            name = path + name + ".class";
            InputStream in = null;
            ByteArrayOutputStream out = null;
            try {
                in = new FileInputStream(new File(name));
                out = new ByteArrayOutputStream();
                int i = 0;
                while ((i = in.read()) != -1){
                    out.write(i);
                }
            }catch (Exception e){
                e.printStackTrace();
            }finally {
                try {
                    out.close();
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return out.toByteArray();
        }
    
    }
    
  4. 测试自定义MyClassLoader

    public class ClassLoaderChecker {
        public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
            
            MyClassLoader m = new MyClassLoader("F:/","myClassLoader");
            Class<?> c = m.loadClass("Zpf");
            System.out.println(c.getClassLoader());
            c.newInstance();
        }
    }
    

    六 为什么使用双亲委派机制去加载类

    6.1 什么是双亲委派机制?

    img

    当某个类加载器需要加载某个.class文件时,它首先把这个任务委托给他的上级类加载器,递归这个操作,如果上级的类加载器没有加载,自己才会去加载这个类。

    6.2 为什么使用双亲委派机制去加载类?

    1. 避免重复字节码的加载;
    2. 提供了JDK核心类加载的沙箱环境;

    6.3 双亲委派机制的作用

    1、防止重复加载同一个.class。通过委托去向上面问一问,加载过了,就不用再加载一遍。保证数据安全。
    2、保证核心.class不能被篡改。通过委托方式,不会去篡改核心.clas,即使篡改也不会去加载,即使加载也不会是同一个.class对象了。不同的加载器加载同一个.class也不是同一个Class对象。这样保证了Class执行安全。

七 类的加载方式

7.1 类的加载方式

  1. 隐式加载 : new;
  2. 显式加载 : LoadClass —> forName进行加载;

7.2 loadClass和forName的区别

img

LoadClass源码

// loadClass 
// 第一步
public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }
-------------------------------------------------------------------------------
// 第二步
protected Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException
    {
        synchronized (getClassLoadingLock(name)) {
            // First, check if the class has already been loaded
            Class<?> c = findLoadedClass(name);
            if (c == null) {
                long t0 = System.nanoTime();
                try {
                    if (parent != null) {
                        c = parent.loadClass(name, false);
                    } else {
                        c = findBootstrapClassOrNull(name);
                    }
                } catch (ClassNotFoundException e) {
                    // ClassNotFoundException thrown if class not found
                    // from the non-null parent class loader
                }

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                //   注意这里
                resolveClass(c);
            }
            return c;
        }
    }
---------------------------------------------------------------------------------
// 第三步
protected final void resolveClass(Class<?> c) {
        resolveClass0(c);
    }

由于resolve传的值默认为false,所以只会进行加载不会执行后续两步的装载过程;接下来看一下forName();

// forName
public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

从上边的源码可以看出默认传入的 initialize 为 true.说明使用 Class.forName() 方法获得 Class 对象是已经执行完初始化的了(注意这里指的是类加载过程中的最后一步:初始化,而非是实例化对象操作的初始化),所以他们的区别

  • 使用 loadClass() 方法获得的 Class 对象只完成了类加载过程中的第一步:加载,后续的操作均未进行。
  • 使用 Class.forName() 方法获得 Class 对象是已经执行完初始化的了

7.3 两者的使用场景

  • 对于Class.forName

    加载 MySQL 的驱动:Class.forName("com.mysql.jdbc.Driver");

    在驱动的源码会发现在类 Driver 中有一个静态代码块,静态代码块会在类加载过程中的初始化阶段执行。

    static {
        try {
            //往DriverManager中注册自身驱动
            DriverManager.registerDriver(new Driver());
        } catch (SQLException var1) {
            throw new RuntimeException("Can't register driver!");
        }
    }
    
  • 对于loadClass

    举个小例子,在 Spring IOC 中,在资源加载器获取要读入的字节的时候,即读取一些 Bean 的配置的时候,如果是以 classpath 的方式来加载,就需要使用 ClassLoader 的 loadClass() 方法来加载。之所以这样做,是和 Spring IOC 的 Lazy Loading 有关,即延迟加载。Spring IOC 为了加快初始化的速度,大量的使用了延迟加载技术,而使用 ClassLoader 的 loadClass() 方法不需要执行类加载过程中的链接和初始化的步骤,这样做能有效的加快加载速度,把类的初始化工作留到实际使用到这个类的时候才去执行

八 Java内存模型😛

8.1 你了解Java的内存模型吗

  1. 内存简介

    img

    32位 : 2^32 的可寻址范围;
    64位 : 2^64 的可寻址范围

  2. 地址空间的划分

    内核空间 : 指操作系统程序和C运行时的空间,包括调度程序等;
    用户空间 : Java程序运行时实际使用的空间;

8.2 Java内存模型JDK1.8

img

8.3 程序计数器(Program Counter Register)

  1. 当前线程所执行的字节码的行号指示器;
  2. 改变计数器的值来选取下一条需要执行的字节码指令;
  3. 和线程是一对一的关系也就是线程私有的;
  4. 对Java方法技术,如果使用的Native方法则计数器值为Undefined;
  5. 没有内存泄露的问题;

8.4 Java虚拟机栈(Stack)

img

  1. Java方法执行的内存模型;
  2. 包含多个栈帧;

8.5 局部变量表和操作数栈

  1. 局部变量表:包含方法执行过程中的所有变量
  2. 操作数栈:入栈、出栈、赋值、交换、产生消费变量

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-oOnGn3oQ-1582124488351)(https://i.loli.net/2019/01/27/5c4da5087e34c.png)]

8.6 递归为什么会引发java.lang.StackOverflowError异常

名词解释:StackOverflowError:栈溢出错误

  1. 栈溢出原因 : 函数调用栈太深了,注意代码中是否有了循环调用方法而无法退出的情况

    如果一个线程在计算时所需要用到栈大小 > 配置允许最大的栈大小,那么Java虚拟机将抛出StackOverflowError

  2. 递归过深,栈帧数超过虚拟栈深度

  3. 解决办法 : 限制递归深度或者使用循环;

  4. **原理:**StackOverflowError 是一个java中常出现的错误:在jvm运行时的数据区域中有一个java虚拟机栈,当执行java方法时会进行压栈弹栈的操作。在栈中会保存局部变量,操作数栈,方法出口等等。jvm规定了栈的最大深度,当执行时栈的深度大于了规定的深度,就会抛出StackOverflowError错误。

8.7 虚拟机栈过多会引发java.lang.OutOfMemoryError异常

  1. 概念:OutOfMemoryError:内存不足错误
  2. 内存溢出原因
    如果一个线程可以动态地扩展本机方法栈,并且尝试本地方法栈扩展(没有大于配置允许最大的栈大小),但是内存不足可以提供, 或者如果不能提供足够的内存来为新线程创建初始的堆(如new Object),那么Java虚拟机将抛出OutOfMemoryError。

8.8 本地方法栈(线程共享😛)

  1. 与虚拟机栈相似,主要作用于标注了Native的方法;

8.9 元空间与永久代

  1. 两者区别

    元空间使用的是本地内存,永久代使用的是JVM的内存;

  2. 使用元空间的好处

    1. 字符串常量池存在永久代中,容易出现性能问题和内存溢出;
    2. 类和方法的信息大小难以确认,给永久代的大小指定带来困难;
    3. 永久代会为GC带来复杂度;
    4. 方便与其他JVM继承;

8.10 堆(heap)

Java 中的堆是 JVM 所管理的最大的一块内存空间,主要用于存放各种类的实例对象。堆内存是 JVM 所有线程共享的部分,在虚拟机启动的时候就已经创建。所有的对象和数组都在堆上进行分配。这部分空间可通过 GC 进行回收。当申请不到空间时会抛出 OutOfMemoryError。

  1. 对象实例的分配区域
  2. GC管理的主要区域

在 Java 中,堆被划分成两个不同的区域:新生代 ( Young )、老年代 ( Old )。新生代 ( Young ) 又被划分为三个区域:Eden、From Survivor、To Survivor。

img

九 JVM内存模型—常考题解析

9.1 JVM三大性能调优参数 -Xms -Xmx -Xss

  • -Xss:规定了每个线程虚拟机栈(堆栈)的大小,默认JDK1.4中是256K,JDK1.5+中是1M
  • -Xms:堆的初始值
  • -Xmx:堆能达到的最大值(一般设置和-Xms相同大小的值,防止heap不够用发生内存抖动)

9.2 Java内存模型中堆和栈的区别—内存分配策略

  1. 内存分配策略

    按照编译原理的观点,程序运行时的内存分配有三种策略,分别是静态的,栈式的,和堆式的.

    • 静态存储:编译时驱动每个数据目标在运行时的存储空间需求
    • 栈式存储:数据区需求在编译时未知,运行时模块入口前确定
    • 堆式存储:编译时或运行时模块入口都无法确定,动态分配
  2. Java内存模型中堆和栈的区别

    • 堆内存用来存放由new创建的对象实例和数组。(重点)
    • 在栈内存中保存的是堆内存空间的访问地址,或者说栈中的变量指向堆内存中的变量(Java中的指针)

**堆和栈的联系:**引用对象,数组时,栈里定义变量保存堆中目标的首地址

img堆与栈区别:

  1. 管理方式:栈自动释放,堆需要GC
  2. 空间大小:栈比堆小**(堆存的是对象数据,栈存的是指针)**
  3. 碎片相关:栈产生的碎片远小于堆
  4. 分配方式:栈支持静态和动态分配,而堆仅支持动态分配
  5. 效率:栈的效率比堆高(栈的灵活度较低,堆的灵活度较高,堆操作的复杂度要高)

9.3 元空间、堆、线程独占部分的联系—内存角度

在这里插入图片描述

img

9.4 不同JDK版本之间的intern()方法的区别——JDK6 VS JDK6+

String s = new String("a");
s.intern();

JDK6:当调用intern方法时,如果字符串常量池先前已经创建出该字符串对象,则返回池中的该字符串的引用。否则,将此字符串对象添加到字符串常量池中,并且返回该字符串对象的引用。

JDK6+:当调用intern方法时,如果字符串常量池先前已经创建出该字符串对象,则返回池中的该字符串的引用。否则,如果该字符串对象已经存在于Java堆中,则将堆中对此对象的引用添加到字符串常量池中,并且返回该引用;如果堆中不存在,则在池中创建该字符串并返回其引用。

本质上就是后来改善版的 intern 方法把字符串存到了堆中,寻找的时候也会到堆中去寻找,原因是为了避免由于永久代内存经常不够用或发生内存泄露,爆出异常java.lang.OutOfMemoryError: PermGen;(元空间与永久代之间最大的区别在于:元空间并不在虚拟机中,而是使用本地内存。)

  • JDK6的例子

    JDK6

    解析:首先我们用引号声明的常量(“a”)都会在字符串常量池中创建出来,而new出来的string对象(new String(“a”))都会在Java heap中创建出来,intern的时候会试图把"a"字符串的副本放进常量池,但是由于常量池已有"a",所以放不进去,所有s1和s2引用不同的地址;"aa"则是首先在Java heap中生成,然后 intern 把"aa"的副本放进常量池,成功放进去;所以s4和s3不同。
    注:此处虽然都是false,但是常量池和Java heap中字符串的生成顺序不一样

  • JDK6+的例子

    在这里插入图片描述

    解析:解析:首先我们用引号声明的常量(“a”)都会在字符串常量池中创建出来,而new出来的string对象(new String(“a”))都会在Java heap中创建出来,intern的时候会试图把"a"字符串引用放进常量池,但是由于常量池已有"a",所以放不进去,所以s1和s2引用不同的地址;"aa"则是首先在Java heap中生成,然后 intern 把"aa"的引用放进常量池,成功放进去;所以s4和s3相同。
    注:新版本的intern与旧版本不同的是:旧版本放进常量池的是字符串的副本,也就是字符串的内容;而新版本则是把字符串的引用放进常量池;所以当常量池不存在字符串的时候,新版本的 intern 之后的引用就和之前的一样

版权声明:本文为qq_34305127原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_34305127/article/details/104402714