栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

JVM面试37问

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

JVM面试37问

目录

JVM面试37问

一、入门部分

1、为什么要学习JVM?

2、你了解哪些JVM产品?

3、JVM的构成有哪几部分?

二、类加载部分

1、你知道哪些类加载器?

2、双亲委派方式加载类有什么优势、劣势?

3、描述一些类加载时候的基本步骤是怎样的?

4、什么情况下会触发类的加载?

5、类加载时静态代码块一定会执行吗?

6、如何理解类的主动加载和被动加载?

7、为什么要自己定义类加载器,如何定义?

三、字节码增强部分

1、为何要学习字节码?

2、如何解读字节码内容?

3、字节码内容由哪几部分构成?

4、什么是字节码增强?

5、为什么要进行字节码增强?

6、你了解哪些字节码增强技术?

7、什么是热替换以及如何实现?

四、JVM运行内存部分

1、JVM运行内存是如何划分的?

2、JVM中的程序计数器用于做什么?

3、JVM虚拟机栈的结构是怎样的?

4、JVM虚拟机栈中局部变量表的作用是什么?

5、JVM虚拟机栈中操作数栈的作用是什么?

6、JVM堆的构成是怎样的?

7、Java对象分配内存的过程是怎样的?

8、JVM年轻代幸存区设置的比较小会有什么问题?

9、JVM年轻代伊甸园区设置的比例比较小会有什么问题?

10、JVM堆内存为什么要分成年轻代和老年代?

11、如何理解JVM方法区以及它的构成是怎样的?

12、什么是逃逸分析以及可以解决什么问题?

13、何为内存溢出以及导致内存溢出的原因?

14、何为内存泄漏以及内存泄漏的原因是什么?

15、JAVA中的四大引用你知道多少?

五、JVM垃圾回收部分

1、何为GC以及为何要GC?

2、你知道哪些GC算法?

3、JVM中有哪些垃圾回收器?

4、服务频繁fullgc,younggc次数较少,可能原因?


JVM面试37问
  • 一、入门部分

1、为什么要学习JVM?

第一:深入理解JVM可以帮助我们从平台角度提高解决问题的能力,

例如:

有效防止内存泄漏(Memory leak)。

优化线程锁的使用 (Thread Lock)。

科学进行垃圾回收 (Garbage collection)。

提高系统吞吐量 (throughput)。

降低延迟(Delay),提高其性能(performance)。

第二:企业面试需要(中高级程序员必备技能)

2、你了解哪些JVM产品?

1.HotSpot VM(Sun公司研发, 2010年由Oracle公司收购).

2.JRockit VM(BEA公司研发, 2008年由Oracle公司收购).

3.J9 VM(IBM内部使用).

4.TaobaoJVM(AliJVM团队开发, 基于OpenJDK开发了AlibabaJDK5).

5.Dalvik

3、JVM的构成有哪几部分?

类加载子系统

运行时数据区

执行引擎

本地方法接口

二、类加载部分

1、你知道哪些类加载器?

1)BootstrapClassLoader(启动类加载器/根类加载器)

        a、C++编写的,程序员无法在程序中获取该类
b、负责加载虚拟机的核心库,比如java.lang.Object
c、没有继承ClassLoader类

负责将/jre/lib下面的类库加载到内存中(比如/jre/lib/rt.jar)。由于引导类加载器涉及到虚拟机本地实现细节,开发者无法直接获取到启动类加载器的引用,所以不允许直接通过引用进行操作。不继承自java.lang.ClassLoader。

也加载-Xbootclasspath参数指定路径,但是必须是虚拟机识别的(仅按照文件名识别),否则就算放在/lib目录下,也不会被根类加载器加载。

根类加载器使用C++实现(HotSpot),是虚拟机的一部分。是唯一一个使用本地代码编写的加载器。

之前看到一个网友提问:“既然所有的Java类,都是由类加载器加载的,那么BootstrapClassLoader,首先是一个类,它是由谁来加载的呢?”。

其实BootstrapClassLoader,不是一个java类。我们在IDE工具中,也引用不了该类。它是在JVM启动时运行的一个特殊的系统类加载器。

由于BootstrapClassLoader对Java不可见,所以返回了null,我们也可以通过某一个类的加载器是否为null来作为判断该类是不是使用BootstrapClassLoader进行加载的依据

2)ExtClassLoader(扩展类加载器)

a、Java编写的,从指定目录中加载类库
b、父加载器是根类加载器
c、是ClassLoader的子类
d、如果用户把创建的jar文件放到指定目录中,也会被扩展加载器加载。

继承自java.lang.ClassLoader

加载/jre/lib/ext目录下的类,或者被java.ext.dirs系统变量指定的路径中的所有类库。它的父加载器是null(因为BootstrapClassLoader是使用C++实现的,没有对应的java类)

jdk8中,系统定义的包有:

1.cldrdata.jar

2.dnsns.jar

3.jaccess.jar

4.jfxrt.jar

5.localedata.jar

6.nashorn.jar

7.sunec.jar

8.sunjce_provider.jar

9.sunpkcs11.jar

10.zipfs.jar

3)AppClassLoader(应用程序类加载器,又称系统类加载器)

a、Java编写的
b、父加载器是扩展类加载器
c、从环境变量或者class.path中加载类
d、是用户自定义类加载的默认父加载器
e、是ClassLoader的子类

是由 Sun 的 AppClassLoader(sun.misc.Launcher$AppClassLoader)实现的。它负责将系统类路径(CLASSPATH)中指定的类库加载到内存中。开发者可以直接使用系统类加载器。由于这个类加载器是ClassLoader中的getSystemClassLoader()方法的返回值,因此一般称为系统(System)加载器。

4)用户自定义类加载器

在Java的日常应用程序开发中,类的加载几乎是上述3种类加载器相互配合执行的,在必要时,我们还可以自定义类加载器,来定制类的加载方式。

自定义类加载器的目的:

(1)隔离加载类

(2)修改类加载的方式

(3)扩展加载源

(4)防止源码泄露

类加载器的关系

BootStrap启动类加载器是Extension扩展类加载器的父类,Extension扩展类加载器是APP应用程序类加载器的父类,APP应用程序类加载器是Custom ClassLoader自定义加载器的父类。

2、双亲委派方式加载类有什么优势、劣势?

优势:

     1.避免类的重复加载, 确保一个类的全局唯一性

Java 类随着它的类加载器一起具备了一种带有优先级的层级关系, 通过这种层级关系可以避免类的重复加载, 当父亲已经加载了该类时, 就没有必要子ClassLoader 再加载一次

2.保护程序安全,防止核心 API 被随意篡改

劣势:

1.无法扩展加载源.

2.无法实现对字节码文件进行加密后再通过类加载器对其进行解密.

3.无法实现隔离类的加载.

4.在某些场景下双亲委派制过于局限,所以有时候必须打破双亲委派机制来达到目的。例如:SPI机制

检查类是否加载的委派过程是单向的, 这个方式虽然从结构上说比较清晰,使各个 ClassLoader 的职责非常明确, 但是同时会带来一个问题, 即顶层的ClassLoader 无法访问底层的 ClassLoader 所加载的类,通常情况下, 启动类加载器中的类为系统核心类, 包括一些重要的系统接口,而在应用类加载器中, 为应用类。 按照这种模式, 应用类访问系统类自然是没有问题, 但是系统类访问应用类就会出现问题。 比如在系统类中提供了一个接口,该接口需要在应用类中得以实现, 该接口还绑定一个工厂方法, 用于创建该接口的实例, 而接口和工厂方法都在启动类加载器中。 这时, 就会出现该工厂方法无法创建由应用类加载器加载的应用实例

双亲委派机制原理:

1.如果一个类加载器收到了类加载请求,它并不会自己先去加载,而是把这个请求委托给父类的加载器去执行。

2.如果父类的加载器还存在其父类加载器,则进一步向上委托,依次递归请求最终达到顶层的启动类加载器。

3.如果父类加载器可以完成类加载任务,就成功返回,倘若父类加载器无法完成此加载任务,子加载器才会尝试自己去加载,这就是双亲委派机制。

3、描述一些类加载时候的基本步骤是怎样的?

一般来说,我们把Java的类加载过程分为三个主要步骤:加载、链接、初始化,具体行为在Java虚拟机规范里有非常详细的定义。

加载阶段(Loading):它是Java将字节码数据从不同的数据源读取到JVM中,并映射为JVM认可的数据结构(Class对象)。这里的数据源可能是各种各样的形态,如jar文件、class文件,甚至是网络数据源等。如果输入数据不是ClassFile的结构,则会抛出ClassFormatError。

加载阶段是用户参与的阶段,我们可以自定义类加载器,去实现自己的类加载过程。

链接阶段(Linking):这是核心的步骤,简单说是把原始的类定义信息平滑地转化入JVM运行的过程中。这里可进一步细分为三个步骤:

  • 验证(Verification),这是虚拟机安全的重要保障,JVM需要核检字节信息是符合Java虚拟机规范的,否则就被认为是VerifyError。这样就防止了恶意信息或者不合规的信息危害JVM的运行。验证阶段有可能触发更多class的加载。
  • 准备(Preparation),创建类或接口中的静态变量,并初始化静态变量的初始值。但这里的“初始化”和下面的显式初始化阶段是有区别的,侧重点在于分配所需要的内存空间,不会去执行更进一步的JVM指令。
  • 解析(Resolution),在这一步会将常量池中的符号引用(symbolic reference)替换为直接引用。在Java虚拟机规范中,详细介绍了类、接口、方法和字段等各个方面的解析。

初始化(Initialization):这一步真正去执行类初始化的代码逻辑,包括静态字段复制的动作,以及执行类定义中的静态初始化块内的逻辑。编译器在编译阶段就会把这部分逻辑整理好,父类型的初始化逻辑优先于当前类型的逻辑。

4、什么情况下会触发类的加载?

以下情况会触发类的初始化:

  1. 遇到new,getstatic,putstatic,invokestatic这4条指令;
  2. 使用java.lang.reflect包的方法对类进行反射调用;
  3. 初始化一个类的时候,如果发现其父类没有进行过初始化,则先初始化其父类(注意!如果其父类是接口的话,则不要求初始化父类);
  4. 当虚拟机启动时,用户需要指定一个要执行的主类(包含main方法的那个类),虚拟机会先初始化这个主类;
  5. 当使用jdk1.7的动态语言支持时,如果一个java.lang.invoke.MethodHandle实例最后的解析结果REF_getstatic,REF_putstatic,REF_invokeStatic的方法句柄,并且这个方法句柄所对应的类没有进行过初始化,则先触发其类初始化;
  6. 调用静态成员时,会加载静态成员真正所在的类及其父类。 通过子类调用父类的静态成员时,只会加载父类而不会加载子类。
  7. 第一次 new 对象的时候 加载(第二次再 new 同一个类时,不需再加载)。
  8. 加载子类会先加载父类。(覆盖父类方法时所抛出的异常不能超过父类定义的范围)

注:如果静态属性有 final 修饰时,则不会加载,当成常量使用。

例:public static final int a =123;

但是如果上面的等式右值改成表达式(且该表达式在编译时不能确定其值)时则会加载类。

例:public static final int a = math.PI

如果访问的是类的公开静态常量,那么如果编译器在编译的时候能确定这个常量的值,就不会被加载;

如果编译时不能确定其值的话,则运行时加载

以下情况不会触发类的初始化:

  1. 同类子类引用父类的静态字段,不会导致子类初始化。至于是否会触发子类的加载和验证,取决于虚拟机的具体实现;
  2. 通过数组定义来引用类,也不会触发类的初始化;例如:People[] ps = new People[100];
  3. 引用一个类的常量也不会触发类的初始化

类的加载顺序

什么时候类加载:第一次需要使用类信息时加载。

类加载的原则:延迟加载,能不加载就不加载。

1、加载静态成员/代码块: 先递归地加载父类的静态成员/代码块(Object的最先);再依次加载到本类的静态成员。

同一个类里的静态成员/代码块,按写代码的顺序加载。

如果其间调用静态方法,则调用时会先运行静态方法,再继续加载。同一个类里调用静态方法时,可以不理会写代码的顺序。

调用父类的静态成员,可以像调用自己的一样;但调用其子类的静态成员,必须使用“子类名.成员名”来调用。

2、加载非静态成员/代码块:(实例块在创建对象时才会被加载。而静态成员在不创建对象时可以加载)

先递归地加载父类的非静态成员/代码块(Object的最先);再依次加载到本类的非静态成员。

同一个类里的非静态成员/代码块,按写代码的顺序加载。同一个类里调用方法时,可以不理会写代码的顺序。

但调用属性时,必须注意加载顺序。一般编译不通过,如果能在加载前调用,值为默认初始值(如:null 或者 0)。 调用父类的非静态成员(private

除外),也可以像调用自己的一样。

3、调用构造方法:先递归地调用父类的构造方法(Object的最先)也就是上溯下行;默认调用父类空参的,也可在第一行写明调用父类某个带参的。再依次到本类的构造方法;构造方法内,也可在第一行写明调用某个本类其它的构造方法。 注意:如果加载时遇到 override

的成员,可看作是所需创建的类型赋值给当前类型。

其调用按多态用法:只有非静态方法有多态;而静态方法、静态属性、非静态属性都没有多态。

假设子类override父类的所有成员,包括静态成员、非静态属性和非静态方法。

由于构造子类时会先构造父类;而构造父类时,其所用的静态成员和非静态属性是父类的,但非静态方法却是子类的;

由于构造父类时,子类并未加载;如果此时所调用的非静态方法里有成员,则这个成员是子类的,且非静态属性是默认初始值的。

5、类加载时静态代码块一定会执行吗?

答:

静态代码块,在类加载时可以执行,但不一定会执行

通过ClassLoader对象的loadClass方法加载类不会执行静态代码块。

下面列举不同的类的加载方式,静态代码块的执行状况:

class ClassA{

//静态代码块,在类加载时可以执行,但不一定会执行

     static {

           System.out.println("static{}");

     }

     }

//-XX:+TraceClassLoading

public class TestClassObject02 {

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

           //定义变量时不会触发类加载

           //Class c0;

           //类的加载方式1

           //Class c1 = ClassA.class;//不会执行静态代码块

           //类的加载方式2

           //Class.forName("com.java.oop.ClassA");//会执行静态代码块

           //类的加载方式3

           

//类的加载方式4

//不指定static{}  loader

//类的加载方式5

ClassLoader loader = ClassLoader.getSystemClassLoader();

loader.loadClass("com.java.oop.ClassA");//不会执行静态代码块

}

}

6、如何理解类的主动加载和被动加载?

主动加载,是有目的性的, 是显示加载, 会执行加载、连接、初始化静态域;

被动加载,是被触发的, 是隐式加载, 只执行加载、连接,不初始化类静态域.

分析如下代码的执行结果,例如:

package com.java.jvm.loader;

class ClassAB{

    public static int a=10;

    static {

        System.out.println("AB.a="+a);

    }

}

class ClassCD extends ClassAB{

    static {

        System.out.println("CD");

    }

}

public class ClassPassiveLoading {

    public static void main(String[] args) {

        System.out.println(ClassCD.a);

    }

}

7、为什么要自己定义类加载器,如何定义?

自己定义类加载器以满足一些特殊的需求:

§ 1. 修改类的加载方式(打破类的双亲委派模型)

§ 2. 扩展加载源(例如从数据库中加载类)

§ 3. 防止源码泄漏(对字节码文件进行加密,用时再通过自定义类加载器对其进行解密)

§ 4. 隔离类的加载(不同框架有相同全限定名的类)

一种简单的方式就是继承URLClassLoader,此类可以直接从指定目录、jar包、网络中加载指定的类资源。

URLClassLoader继承ClassLoader,可以从指定目录、jar包、网络中加载指定的类资源,我们自己定义类加载器,最简单的方式就是继承URLClassLoader进行类加载实践。

我们可以通过继承java.lang.ClassLoader抽象类的方式,实现自己的类加载器,以满足一些特殊的需求。建议把自定义的类加载逻辑写在findclass()方法中。

  • 三、字节码增强部分

1、为何要学习字节码?

对于开发人员,了解字节码可以更准确、直观地理解Java语言中更深层次的东西,比如通过字节码,可以很直观地看到Volatile关键字如何在字节码上生效。另外,字节码增强技术在Spring AOP、各种ORM框架、热部署中的应用屡见不鲜,深入理解其原理对于我们来说大有裨益。除此之外,由于JVM规范的存在,只要最终可以生成符合规范的字节码就可以在JVM上运行,因此这就给了各种运行在JVM上的语言(如Scala、Groovy、Kotlin)一种契机,可以扩展Java所没有的特性或者实现各种语法糖。理解字节码后再学习这些语言,可以“逆流而上”,从字节码视角看它的设计思路,学习起来也“易如反掌”。

2、如何解读字节码内容?

1)直接解读

IntTests.java的源代码编译后,可以通过notepad++(需要安装一下HEX-Editor插件)打开IntTests.class文件,文件内容默认是一种16进制的格式,

2)javap指令应用

在IntTests.class目录使用如下代码对类进行反编译,

例如:

javap -verbose IntTests.class  //可以使用javap –help查看帮助

3)jclasslib插件应用

如果每次查看反编译后的字节码都使用javap命令的话,会非常繁琐。这里推荐一个Idea插件,这个插件的名字为jclasslib。代码在编译后,我们可以在菜单栏”View”中选择”Show Bytecode With jclasslib”,可以很直观地看到当前字节码文件的类信息、常量池、方法区等信息。

3、字节码内容由哪几部分构成?

§ magic(魔数)

§ minor_version(次版本号)

§ major_version(主版本号)

§ constant_pool_count(常量池计数器)

§ constant_pool[constant_pool_count-1](常量池)

§ access_flags(类的访问标志)

§ this_class(当前类名索引值)

§ super_class(父类名索引值)

§ interfaces_count(接口计数)

§ interfaces[interfaces_count](接口数组)

§ fields_count(成员变量计数)

§ fields[fields_count](成员变量数组)

§ methods_count(方法计数)

§ methods[methods_count](方法数组)

§ attributes_count(属性计数)

§ attributes[attributes_count](属性数组)

4、什么是字节码增强?

字节码增强技术相当于是一把打开运行时JVM的钥匙,利用它可以对现有字节码进行修改或者动态生成新的字节码,进而对运行中的程序做修改,实现热部署。也可以跟踪JVM运行中程序的状态,进行性能诊断等。

此外,我们平时使用的动态代理、AOP也与字节码增强密切相关,它们实质上还是利用各种手段生成符合规范的字节码文件。综上所述,掌握字节码增强后可以高效地定位并快速修复一些棘手的问题(如线上性能问题、方法出现不可控的出入参需要紧急加日志等问题),也可以在开发中减少冗余代码,大大提高开发效率。

5、为什么要进行字节码增强?

可以高效地定位并快速修复一些棘手的问题(如线上性能问题、方法出现不可控的出入参需要紧急加日志等问题),也可以在开发中减少冗余代码,大大提高开发效率。

可以在完全不侵入业务代码的情况下植入代码逻辑,所以可以用它来做一些酷酷的事,比如下面的:

1)cglib代理;

2)热部署;

3)调用链跟踪埋点;

4)动态插入log;

5)测试代码覆盖率跟踪;

6)…

6、你了解哪些字节码增强技术?

常见的字节码增强技术大致分为两类:静态增强和动态增强;静态增强最常见的就是AspectJ了,可以直接编译类,有自己的语法;动态增强包括:ASM、Javassist、Java Agent、Cglib、Java Proxy;下面简单介绍几种:

ASM技术

概述

对于需要手动操纵字节码的需求,可以使用ASM,它可以直接生产 .class字节码文件,也可以在类被加载入JVM之前动态修改类行为。ASM的应用场景有AOP(Cglib就是基于ASM)、热部署、修改其他jar包中的类等。当然,涉及到如此底层的步骤,实现起来也比较麻烦。

Javassist技术

概述

Javassist是一个用于分析、编辑和创建Java字节码的类库,相比ASM在指令层次上操作字节码会更加简单直观。可以无须关注字节码刻板的结构,直接使用java编码的形式,而不需要了解虚拟机指令,就能动态改变类的结构或者动态生成类。

Java Agent技术

简介

Java Agent是Java Instrumentation API的一部分,它提供了向现有已编译的Java类添加字节码的功能,相当于字节码插桩的入口。可以侵入运行在JVM上的应用程序,进而修改应用程序中各种类的字节码。

7、什么是热替换以及如何实现?

热替换就是通过一定的字节码增强技术, 侵入运行在JVM上的应用程序, 进而修改应用程序中各种类的字节码, 实现不停机,不停服更新或升级服务的技术.

所谓类的热替换,本质上,就是触发了类的重新加载,并在类加载过程中,通过Hook方法,修改类的字节码,并基于修改后的字节码,重新初始化类而已。

实现热替换的

第一步就是动态编译,将.java文件编译成为.class文件

第二步是动态加载,编写一个自定义的类加载器,将编译好的类加载到运行环境中去

类的加载是由不同的加载器共同完成的

BootstrapClassLoader负责sum.boot.class.path路径下类的加载,默认为jre/lib或者-Xbootclasspath指定的jar包

ExtClassLoader 负责java.ext.dirs路径下类的加载,默认为jre/lib/ext或者-Djava.ext.dirs指定的jar包

AppClassLoader 负责加载java.class.path路径下类的加载,默认为classpath设定值下的jar包

CustomClassLoader自定义加载器。

每个加载器都有一个自己的命名空间,同一加载器名字相同的类只能存在一个,并且仅加载一次。java中,即使是同一个类文件,如果是由不同的类加载器实例加载的,他们的类型也是不相同的。

第一步:创建业务service类,将此类作为字节码增强对象

package com.java.jvm.bytecode.service;

public class CycleService {

    public void doCycle(){

       System.out.println("doCycle()");

    }

}

第二步:创建Transformer对象,用于对CycleService对象进行功能增强

package com.java.jvm.bytecode.instrument;

import javassist.ClassPool;

import javassist.CtClass;

import javassist.CtMethod;

import java.lang.instrument.ClassFileTransformer;

import java.lang.instrument.IllegalClassFormatException;

import java.security.ProtectionDomain;

public class DefaultClassTransformer implements ClassFileTransformer {

   

  @Override

    public byte[] transform(ClassLoader loader, String className,

Class classBeingRedefined, ProtectionDomain protectionDomain,

 byte[] classfileBuffer) throws IllegalClassFormatException {

        System.out.println("Transforming " + className);

        try {

            ClassPool cp = ClassPool.getDefault();

            CtClass cc = cp.get("com.java.jvm.bytecode.service.CycleService");

            CtMethod m = cc.getDeclaredMethod("doCycle");

            m.insertBefore("{ System.out.println("start"); }");

            m.insertAfter("{ System.out.println("end"); }");

            byte[] bytes = cc.toBytecode();

            return bytes;

        } catch (Exception e) {

            e.printStackTrace();

        }

        return null;

    }

}

第三步:创建Agent对象,用于调用DefaultClassTransformer对象执行字节码增强,在Agent中可定义两个方法进行不同时间点进行增强

    1、premain方法,此方法在main方法执行之前执行。(方法声明固定写法)

2、agentmain方法,此方法在main方法启动后,也就时候程序运行时进行执行。(方法声明固定写法)

package com.java.jvm.bytecode.instrument;

import com.java.jvm.bytecode.service.CycleService;

import java.lang.instrument.Instrumentation;

public class DefaultAgent {

    

    public static void premain(String args, Instrumentation inst){

        System.out.println("premain->"+args);

        inst.addTransformer(new DefaultClassTransformer(),true);

    }

    

    public static void agentmain(String args, Instrumentation inst){

        System.out.println("agentmain->"+args);

        inst.addTransformer(new DefaultClassTransformer(),true);

        try {

            //指明哪些类需要重新加载

            inst.retransformClasses(CycleService.class);

        }catch (Exception e){

            System.out.println("agent error");

        }

    }

}

第四步:添加maven插件用于对项目进行打包

    

        org.apache.maven.plugins

        maven-compiler-plugin

        

            8

            8

        

    

    

        org.apache.maven.plugins

        maven-jar-plugin

        3.2.0

        

            

                

                    true

                

                

                    com.java.jvm.bytecode.instrument.DefaultAgent

                    com.java.jvm.bytecode.instrument.DefaultAgent

                    true

                    true

                

            

        

    

依赖中,Premain-Class和Agent-Class用于指定代理类,Can-Redefine-Classes 是否需要重新定义所有类,默认为false,可选。Can-Retransform-Classes 是否需要retransform,默认为false,可选。依赖添加后,先执行maven clean对原有类文件进行清除,然后执行maven package对项目进行打包。

说明,当一个代理jar包中的manifest文件中,既有Premain-Class又有Agent-Class时,如果以命令行方式在VM启动前指定代理jar,则使用Premain-Class;反之如果在VM启动后,动态添加代理jar,则使用Agent-Class。

第五步:创建CycleServiceTests类,对CycleService对象进行调用,也就是启动服务,假如需要在此服务启动之前进行增强,可以考虑在idea的vm参数中添加-javaagent:E:TCGBIVDEVCODESCSDNCODEScgb2202codes1-javatarget1-java-1.0-SNAPSHOT.jar,这里的jar位

package com.java.jvm.bytecode;

import com.java.jvm.bytecode.service.CycleService;

import java.lang.management.ManagementFactory;

public class CycleServiceTests {

    public static void main(String[] args) {

        String name = ManagementFactory.getRuntimeMXBean().getName();

        String s = name.split("@")[0];

        //打印当前Pid

        System.out.println("pid:"+s);

        CycleService cs=new CycleService();

        while(true) {

            try {

                cs.doCycle();

                Thread.sleep(3000);

            }catch (Exception e){

                e.printStackTrace();

            }

        }

    }

}

说明,假如此类的运行是命令行执行,可以通过java -javaagent:xxx.jar CycleServiceTests方式进行实现。

第六步:添加tools依赖

程序启动之后,通过VirtualMachine 的 attach api加载 Java Agent,这组 api 其实是 JVM 进程之间的的沟通桥梁,底层通过socket 进行通信,JVM A 可以发送一些指令给JVM B,B 收到指令之后,可以执行对应的逻辑,比如在命令行中经常使用的 jstack、jps 等,很多都是基于这种机制实现的。VirtualMachine 在jdk的lib下面的tools.jar中,如果不在classpath的话,要加进去。可通过添加依赖的方式进行tools的依赖配置。

    com.sun

    tools

    1.8

    system

    ${java.home}/../lib/tools.jar

第七步:创建AgentInstrumentTests类

package com.java.jvm.bytecode;

import com.sun.tools.attach.VirtualMachine;

import java.lang.management.ManagementFactory;

public class AgentInstrumentTests {

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

        //传入目标 JVM pid(这里的id为CycleServiceTests类中打印的进程id)

        VirtualMachine vm = VirtualMachine.attach("4328");

        vm.loadAgent("E:/TCGBIV/DEVCODES/CGB2112CODES/01-java/target/01-java-1.0-SNAPSHOT.jar");

    }

}

第八步:分别运行CycleServiceTests、AgentInstrumentTests类进行测试。

  • 四、JVM运行内存部分

1、JVM运行内存是如何划分的?

根据《Java虚拟机规范》的规定,运行时数据区通常包括这几个部分:程序计数器(Program Counter Register)、Java虚拟机栈(VM Stack)、本地方法栈(Native Method Stack)、方法区(Method Area)、堆(Heap)。

2、JVM中的程序计数器用于做什么?

程序计数器(Program Counter Register)也称之为PC寄存器,是一块较小的内存空间,用来存储指向下一条指令的地址,也可以看作是当前线程执行的字节码的行号指示器。

在虚拟机的概念模型里,字节码解析器的工作是通过改变这个计数器的值来选取下一条 要执行的字节码指令。分支、循环、跳转、异常处理、线程恢复等基础功能都需要依赖这个计数器来完成。

3、JVM虚拟机栈的结构是怎样的?

每个线程都有自己的栈,栈中的数据都是以栈帧(Stack Frame)的格式存在,在这个线程上正在执行的每个方法都各自对应一个栈帧(Stack Frame)。每个栈帧中存储着:

1)局部变量表(Local Variables)

2)操作数栈(Operand Stack)(或表达式栈)

3)动态链接(Dynamic Linking)(或指向运行时常量池的方法引用)

4)方法返回地址(Return Address)(或方法正常退出或者异常退出的定义)

5)一些附加信息

总之,栈帧是一个内存区块,是一个数据集,维系着方法执行过程中的各种数据信息。

4、JVM虚拟机栈中局部变量表的作用是什么?

局部变量表也称之为局部变量数组或本地变量表,用于存放方法参数和方法内部定义的局部变量信息。在Java程序被编译为Class文件时,就已经确定了每个方法所需局部变量表的大小。

局部变量表以变量槽为最小单位,每个变量槽可以存放一个32位以内的数据类型,故每个变量槽都应该能存放 boolean、byte、char、short、int、float、refrence或returnAddress类型的数据,对于long、double两种,会占用两个变量槽。

5、JVM虚拟机栈中操作数栈的作用是什么?

每一个独立的栈帧除了包含局部变量表以外,还包含一个后进先出(Last - In - First -Out)的 操作数栈(Operand Stack)。

操作数栈,在方法执行过程中,根据字节码指令,往栈中写入数据或提取数据,即入栈(push)和 出栈(pop)。

6、JVM堆的构成是怎样的?

JAVA堆内存在JVM中可分为年轻代和老年代。年轻代又分为Eden和两个Survivor区。

7、Java对象分配内存的过程是怎样的?

基于此内存架构,对象内存分配过程如下:

1)编译器通过逃逸分析(JDK8已默认开启),确定对象是在栈上分配还是在堆上分配。

2)如果是在堆上分配,则首先检测是否可在TLAB(Thread Local Allocation Buffer)上直接分配。

3)如果TLAB上无法直接分配则在Eden加锁区进行分配(线程共享区)。

4)如果Eden区无法存储对象,则执行Yong GC(Minor Collection)。

5)如果Yong GC之后Eden区仍然不足以存储对象,则直接分配在老年代。

说明:在对象创建时可能会触发Yong GC,此GC过程的简易原理图分析如下:

其中:

6)新生代由Eden 区和两个幸存区构成(假定为s1,s2), 任意时刻至少有一个幸存区是空的(empty),用于存放下次GC时未被收集的对象。

7)GC触发时Eden区所有”可达对象”会被复制到一个幸存区,假设为s1,当幸存区s1无法存储这些对象时会直接复制到老年代。

8)GC再次触发时Eden区和s1幸存区中的”可达对象”会被复制到另一个幸存区s2,同时清空eden区和s1幸存区。

9)GC再次触发时Eden区和s2幸存区中的”可达对象”会被复制到另一个幸存区s1,同时清空eden区和s2幸存区.依次类推。

10)当多次GC过程完成后,幸存区中的对象存活时间达到了一定阀值(可以用参数 -XX:+MaxTenuringThreshold 来指定上限,默认15),会被看成是“年老”的对象然后直接移动到老年代。

8、JVM年轻代幸存区设置的比较小会有什么问题?

伊甸园区被回收时,对象要拷贝到幸存区,假如幸存区比较小,拷贝的对象比较大,对象就会直接存储到老年代,这样会增加老年代GC的频率。而分代回收的思想就会被弱化。

9、JVM年轻代伊甸园区设置的比例比较小会有什么问题?

伊甸园设置的比较小,会增加GC的频率,可能会导致STW的时间边长,影响系统性能。

10、JVM堆内存为什么要分成年轻代和老年代?

为了更好的实现垃圾回收。

11、如何理解JVM方法区以及它的构成是怎样的?

概述

方法区(Methed Area)是一种规范,用于存储已被虚拟机加载的类信息、常 量、静态变量、即时编译后的代码等数据。不同jdk,方法区的实现不同,HotSpot 虚拟机在 JDK 8 中使 用 Native Memory 来实现方法区。

在JDK8的HostSpot虚拟机中方法区的落地实现是元数据区(Metaspace),但是Metaspace并不在虚拟机中,而是使用本地内存。因此,默认情况下,元空间(Metaspace)的大小仅受本地内存限制,但可以通过一些参数来指定元空间的大小。

方法区构成分析

方法区(Methed Area)是一种规范,用于存储已被虚拟机加载的类信息、常 量、静态变量、即时编译后的代码等数据。

      1)类信息包括对每个加载的类型(类class、接口interface、枚举enum、注解annotation)以及属性和方法信息。

      2)常量信息可以看做是一张表,虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量等类型。

12、什么是逃逸分析以及可以解决什么问题?

逃逸分析一种数据分析算法,基于此算法可以有效减少Java对象在堆内存中的分配。Hotspot虚拟机的编译器能够分析出一个新对象的引用范围,然后决定是否要将这个对象分配到堆上。例如:

      1)当一个对象在方法中被定义后,对象只在方法内部使用,则认为没有发生逃逸。

      2)当一个对象在方法中被定义后,它被外部方法所引用,则认为发生逃逸。

13、何为内存溢出以及导致内存溢出的原因?

何为内存溢出:

内存中剩余的内存不足以分配给新的内存请求就会内存溢出。内存溢出可能直接导致系统崩溃。

内存溢出的原因:

内存泄漏是导致内存溢出的一种原因,但内存溢出不全是由内存泄漏引起的,还可能是:

1)创建的对象太大导致堆内存溢出

2)创建的对象太多导致堆内存溢出

3)方法出现了无限递归调用导致栈内存溢出

4)方法区内存空间不足导致内存溢出。

14、何为内存泄漏以及内存泄漏的原因是什么?

何为内存泄漏:

动态分配的内存空间,在使用完毕后未得到释放,结果导致一直占据该内存单元,直到程序结束。这个现象称之为内存泄漏。因此良好的代码规范,可以有效地避免这些错误。

导致内存泄漏的原因:

1)大量使用静态变量(静态变量与程序生命周期一样)

2)IO/连接资源用完没关闭(记得执行close操作)

3)内部类的使用方式存在问题(实力内部类或默认引用外部类对象)

4)缓存(Cache)应用不当(尽量不要使用强引用)

5)ThreadLocal应用不当(用完记得执行remove操作)

15、JAVA中的四大引用你知道多少?

在谈这四种引用之前,先要明确一点,所说的情况都是对象可达的情况,如果对象不可达即对象引用已经不存在了,不论哪种引用垃圾收集器都会进行回收

引用等级: 强引用 > 软引用 >弱引用 >虚引用

Java通过对象的四种引用从而控制,对象的生命周期。

1)强引用(StrongReference)

强引用是使用最多、最普遍的。他就是我们经常用的引用赋值。如"Object o=new Object()"这种引用关系。这种引用只要还存在,垃圾回收器就永远不会回收被引用的对象。(死都不回收)

强引用只要这种引用存在,垃圾回收器就不会回收,因此在不当的操作中可能造成内存泄漏

范围:强引用是使用最普遍的引用。

效果说明:如果一个对象具有强引用,那垃圾回收器绝不会回收它。当内存空间不足,Java虚拟机宁愿抛出OutOfMemoryError错误,使程序异常终止,也不会靠随意回收具有强引用的对象来解决内存不足的问题。

问题:虚拟机宁可让整个程序崩溃也不愿意回收,导致程序稳定性收到巨大影响。

Object obj = new Object();

//可直接通过obj取得对应的对象 如obj.equels(new Object());

而这样 obj对象对后面new Object的一个强引用,只有当obj这个引用被释放之后,对象才会被释放掉,这也是我们经常所用到的编码形式。

2)软引用(SoftReference)

程序将要发生内存溢出之前,会把这些引用列为二次回收(第一次回收是不可达的对象)的范围内,如果这次回收之后依然没有足够的内存,程序才会抛出内存溢出异常(内存不足即回收)

如何使用软引用呢? 声明一个强引用,把变量传给软引用,然后强引用指向null即可

效果说明:如果一个对象只具有软引用,则内存空间足够,垃圾回收器就不会回收它;如果内存空间不足了,就会回收这些对象的内存。只要垃圾回收器没有回收它,该对象就可以被程序使用。

功能:所以,软引用可用来实现内存敏感的高速缓存。软引用可以和一个引用队列(ReferenceQueue)联合使用,如果软引用所引用的对象被垃圾回收器回收,Java虚拟机就会把这个软引用加入到与之关联的引用队列中。

Object obj = new Object();

SoftReference sf = new SoftReference(obj);

obj = null;

sf.get();//有时候会返回null

这时候sf是对obj的一个软引用,通过sf.get()方法可以取到这个对象,当然,

当这个对象被标记为需要回收的对象时,则返回null;

软引用主要用户实现类似缓存的功能,在内存足够的情况下直接通过软引用取值,

无需从繁忙的真实来源查询数据,提升速度;当内存不足时,自动删除这部分缓存数据,从真正的来源查询这些数据。

3)弱引用(WeakReference)

被弱引用关联的对象只能存活到下次垃圾回收之前,在垃圾收集器工作时,无论内存足不足够都会回收掉被弱引用关联的对象(垃圾收集工作就回收)

弱引用与软引用的区别:弱引用的对象拥有更短暂的生命周期。

效果说明:在垃圾回收器线程扫描它所管辖的内存区域的过程中,一旦发现了只具有弱引用的对象,不管当前内存空间足够与否,都会回收它的内存。不过,由于垃圾回收器是一个优先级很低的线程,因此不一定会很快发现那些只具有弱引用的对象。

功能:弱引用可以和一个引用队列(ReferenceQueue)联合使用,如果弱引用所引用的对象被垃圾回收,Java虚拟机就会把这个弱引用加入到与之关联的引用队列中。

Object obj = new Object();

WeakReference wf = new WeakReference(obj);

obj = null;

wf.get();//有时候会返回null

wf.isEnQueued();//返回是否被垃圾回收器标记为即将回收的垃圾

弱引用是在第二次垃圾回收时回收,短时间内通过弱引用取对应的数据,可以取到,当执行过第二次垃圾回收时,将返回null。

弱引用主要用于监控对象是否已经被垃圾回收器标记为即将回收的垃圾,可以通过弱引用的isEnQueued方法返回对象是否被垃圾回收器标记。

4)虚引用(PhantomReference)

一个对象是否有虚引用存在,完全不会影响其生存时间,也无法通过虚引用来获取对象的实例。为一个对象设置虚引用存在唯一目的就是能在这个对象被回收器回收之前收到一个系统通知(一般用于对象回收的跟踪)

效果说明:“虚引用”顾名思义,就是形同虚设,与其他几种引用都不同,虚引用并不会决定对象的生命周期。

  如果一个对象仅持有虚引用,那么它就和没有任何引用一样,在任何时候都可能被垃圾回收器回收。

  虚引用主要用来跟踪对象被垃圾回收器回收的活动。

  虚引用与软引用和弱引用的一个区别在于:

问题:虚引用必须和引用队列(ReferenceQueue)联合使用。当垃圾回收器准备回收一个对象时,如果发现它还有虚引用,就会在回收对象的内存之前,把这个虚引用加入到与之关联的引用队列中。

  程序可以通过判断引用队列中是否已经加入了虚引用,来了解被引用的对象是否将要被垃圾回收。如果程序发现某个虚引用已经被加入到引用队列,那么就可以在所引用的对象的内存被回收之前采取必要的行动。

//自定义Heisuan类  ,并且继承引用队列 extends ReferenceQueue

Heisuan obj = new Heisuan();

PhantomReference pf = new PhantomReference(obj,null);

obj=null;

//永远返回null

System.out.println(pf.get());

pf.isEnqueued();//返回是否从内存中已经删除

System.out.println(pf);

虚引用是每次垃圾回收的时候都会被回收,通过虚引用的get方法永远获取到的数据为null,因此也被成为幽灵引用。

  • 五、JVM垃圾回收部分

1、何为GC以及为何要GC?

何为GC

GC(Garbage Collection)称之为垃圾回收,是对内存中的垃圾对象,采用一定的算法进行内存回收的一个动作。比方说:java中的垃圾回收会对内存中的对象进行遍历,对存活的对象进行标记,其未标记对象可认为是垃圾对象,然后基于特定算法进行回收。

GC是垃圾收集的意思,内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显式操作方法。Java程序员不用担心内存管理,因为垃圾收集器会自动进行管理。要请求垃圾收集,可以调用下面的方法之一:System.gc()或Runtime.getRuntime().gc(),但JVM可以屏蔽掉显式的垃圾回收调用。

为何要GC

垃圾回收可以有效的防止内存泄露,有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行,在不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。在Java诞生初期,垃圾回收是Java最大的亮点之一,因为服务器端的编程需要有效的防止内存泄露问题,然而时过境迁,如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS系统比Android系统有更好的用户体验,其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。

补充:垃圾回收机制有很多种,包括:分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。标准的Java进程既有栈又有堆。栈保存了原始型局部变量,堆保存了创建的对象。Java平台对堆内存回收和再利用的基本算法被称为标记和清除,但是Java对其进行了改进,采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域,在垃圾收集过程中,可能会将对象移动到不同区域:

- 伊甸园(Eden):这是对象最初诞生的区域,并且对大多数对象来说,这里是它们唯一存在过的区域。

- 幸存者乐园(Survivor):从伊甸园幸存下来的对象会被挪到这里。

- 终身颐养园(Tenured):这是足够老的幸存对象的归宿。年轻代收集(Minor-GC)过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时,就会触发一次完全收集(Major-GC),这里可能还会牵扯到压缩,以便为大对象腾出足够的空间。

与垃圾回收相关的JVM参数:

-Xms / -Xmx — 堆的初始大小 / 堆的最大大小

-Xmn — 堆中年轻代的大小

-XX:-DisableExplicitGC — 让System.gc()不产生任何作用

-XX:+PrintGCDetails — 打印GC的细节

-XX:+PrintGCDateStamps — 打印GC操作的时间戳

-XX:NewSize / XX:MaxNewSize — 设置新生代大小/新生代最大大小

-XX:NewRatio — 可以设置老生代和新生代的比例

-XX:PrintTenuringDistribution — 设置每次新生代GC后输出幸存者乐园中对象年龄的分布

-XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold:设置老年代阀值的初始值和最大值

-XX:TargetSurvivorRatio:设置幸存区的目标使用率

深入理解GC的工作机制,可以帮你写出更好的Java应用,提高开发效率,同时也是进军大规模应用开发的一个前提。

2、你知道哪些GC算法?

1)标记清除

标记清除(Mark-Sweep)算法分为“标记”和“清除”阶段,它首先会标记出内存中所有不需要回收的对象,然后从内存中清除所有未标记的对象。 如图所示:

标记清除算法的的优点是简单直接,缺点是效率低,并且可能会产生大量不连续的碎片。说它效率低是因为标记和清除两个过程都需要扫描内存空间(第一次:标记存活对象,第二次:清除没有标记的对象)。还有就是,清除后产生的大量不连续的内存碎片空间,无法满足较大对象的存储需求,这样就可能会再次触发垃圾回收。所以此垃圾回收算法,应该适合对象存活率较高的的内存区域(比方说JVM中的老年代)。

2)标记复制

标记复制(Mark-Copy)算法是将内存分为大小相同的两块,当这一块使用完了,就把当前存活的对象复制到另一块,然后一次性清空当前区块。如图所示:

“标记-复制”算法的缺点显而易见,就是内存空间利用率低,适用于那些对象生命周期短、回收频率高的内存区域(比方说JVM中的年轻代)。

3)标记整理

标记整理清除(Mark-Sweep-Compact)算法结合了“标记-清除”和“复制”两个算法的优点。第一阶段从根节点开始标记所有被引用对象,第二阶段遍历整个堆,把存活对象“压缩”复制到堆的其中一块空间中,按顺序排放。第三阶段清理掉存活边界以外的全部内存空间。如图所示:

系统GC时每次执行清除(sweeping)操作, JVM 都必须保证“不可达对象“占用的内存能被回收然后重用。内存是被回收了,但这有可能会产生大量的内存碎片(类似于磁盘碎片), 进而引发两个问题:

对象创建时,执行写入操作越来越耗时, 因为寻找一块足够大的空闲内存会变得更加麻烦。

对象创建时, JVM需要在连续的内存块中为对象分配内存。如果碎片问题很严重, 直至没有空闲片段能存放新创建的对象,就会发生内存分配错误(allocation error)。

为了解决碎片问题,JVM在启动GC执行垃圾收集的过程中, 不仅仅是标记和清除, 还需要执行 “内存碎片整理”。这个过程会让所有可达对象(reachable objects)进行依次移动,进而可以消除(或减少)内存碎片,并为新对象提供更大并且连续的内存空间。

标记整理算法避免了“标记-清除”的碎片问题,同时也避免了“复制”算法的空间问题,由于需要向一侧移动等一系列操作,其效率相对低一些,但对内存空间管理上十分优异。适用于那些生命周期长、回收频率低,但注重回收一次内存空间得到足够释放的场景。

3、JVM中有哪些垃圾回收器?

1)Serial收集器

Serial GC是最古老也是最基本的收集器,但是现在依然广泛使用,JAVA SE5和JAVA SE6中客户端虚拟机采用的默认配置。

2)Parallel收集器

Parallel 收集器为并行收集器,它可利用多个或多核CPU优势实现多线程并行GC操作,其目标是减少停顿时间,实现更高的吞吐量(Throughput)。

3)CMS 收集器

CMS的官方名称为 “Mostly Concurrent Mark and Sweep Garbage Collector”,其设计目标是追求更快的响应时间。

4)G1收集器

G1(Garbage-First )收集器是一种工作于服务端模式的垃圾回收器,主要面向多核,大内存的服务器。G1 在实现高吞吐的同时,也最大限度满足了GC 停顿时间可控的目标。在Oracle JDK7 update 4 后续的版本中已全面支持G1 回收器功能。G1收集器主要为有如下需求的程序设计:

  1. 可以像CMS 收集器一样能同时和应用线程一起并发的执行。
  2. 减少整理内存空间时的停顿时间。
  3. 要满足可预测的GC停顿时间需求。
  4. 不能牺牲太多的吞吐性能。

未来 G1 计划要全面取代CMS。G1相比CMS有更多的优势,G1是压缩型收集器,可以实现更有效的空间压缩,消除大部分潜在的内存碎片问题。G1提供了更精准的可预测的垃圾停顿时间设置,可满足用户在指定垃圾回收时间上的需求。

在G1中,堆不再分成连续的年轻代和老年代空间,而是划分为多个(通常是2048个)可以存放对象的小堆区(smaller heap regions)。每个小堆区都可能是Eden区, Survivor区或者Old区. 在逻辑上, 所有的Eden区和Survivor区合起来就是年轻代, 所有的Old区拼在一起那就是老年代,

4、服务频繁fullgc,younggc次数较少,可能原因?

原因一:系统承载高并发请求,或者处理数据量过大,导致Young GC很贫乏,而且每次Young GC过后存活对象太多,内存分配不合理,Survivor区过小,导致对象频繁进入老年代,频繁触发Full GC。

原因二:系统一次性加载过多数据进内存,搞出来很多大对象,导致频繁有大对象进入老年带,必然频繁触发Full GC。

原因三:系统发生了内存泄漏,莫名其妙创建大量的对象,始终无法回收,一直占用在老年代里,必然频繁触发Full GC。

原因四:Metaspace(永久代)因为加载类过多触发Full GC。

原因五:误调用System.gc()触发Full GC。

解决方法:

原因一的解决方法是合理分配内存,调大Survivor区;

原因二、三,dump出内存快照,用MAT工具进行分析;

上述原因都不是,必然是第四、五种原因。

转载请注明:文章转载自 www.mshxw.com
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号