Java高级开发JVM面试总结

1、简述jvm 

JVM就是我们常说的java虚拟机，它是整个java实现跨平台的 最核心的部分，所有的java程序会首先被编译为.class的类文件，这种类文件可 以在虚拟机上执行，也就是说class并不直接与机器的操作系统相对应，而是经过虚拟机间接与操作系统交互，由虚拟机将程序解 释给本地系统执行。JVM 是 Java 平台的基础，和实际的机器一样，它也有自己的指令集，并且在运行 时操作不同的内存区域。 JVM 通过抽象操作系统和 CPU 结构，提供了一种与平台无关的代码执行方法，即与特殊的实现方 法、主机硬件、主机操作系统无关。但是在一些小的方面， JVM 的实现也是互不相同的，比如垃圾回收 算法，线程调度算法（可能不同 OS 有不同的实现）。 JVM 的主要工作是解释自己的指令集（即字节码）到 CPU 的指令集或 OS 的系统调用，保护用户免被恶意程序骚扰。 JVM 对上层的 Java 源文件是不关心的，它关注的只是由源文件生成的类文件（ class file ）。类文件的 组成包括 JVM 指令集，符号表以及一些补助信息。

 

2、判断对象是否需要回收的方法有两种

1.引用计数 

当某对象的引用数为0时，便可以进行垃圾收集。 

2.根搜索算法（可达性分析算法） 

java采用。通过一系列名为“GC root”的对象作为起点，从这些点开始向下搜索，搜索走过的路劲叫做引用链。当一个对象到GC root没有任何引用链时，则证明此对象是不可用的。 

Gc ROOT:

1、虚拟机栈中的引用的对象。

2、方向区中的类静态属性引用的对象。

3、方法区中常量引用的对象

4、本地方法栈中引用的对象。

 

3、一个对象的回收过程

1.该对象没有与GC Roots相连

2.该对象没有重写finalize()方法或finalize()已经被执行过则直接回收（第一次标记）

、 否则将对象加入到F-Queue队列中（优先级很低的队列）在这里finalize()方法被执行，之后进行第二次标记，如果对象仍然应该被GC则GC，否则移除队列。（在finalize方法中，对象很可能和其他 GC Roots中的某一个对象建立了关联，finalize方法只会被调用一次，且不推荐使用finalize方法）

 

4、如何回收对象

分为年轻代，老年代，永久代。 

a：永久代： 

就是指方法区要回收的内存：主要有废弃常量和无用的类两部分内容。判定一个类是否是“无用的类”需满足三个条件： 

1 该类所有的实例都已近被回收，java堆不存在该类的任何实例。 

2 加载该类的classLoader已经被回收 

3 该类对应的java.lang.Class对象没有在任何地方被引用，无法在任何地方通过反射访问该类的方法。

b：新生代： 

新生代 ( Young ) 又被划分为三个区域：Eden、From Survivor、To Survivor。这样划分的目的是为了使 JVM 能够更好的管理堆内存中的对象，包括内存的分配以及回收。采用复制算法回收。 

复制算法是把整个堆分成两个半区（From，To）， GC的过程其实就是把存活对象从一个半区From拷贝到另外一个半区To的过程，而在下一次回收时，两个半区再互换角色。在移动结束后，再更新对象的指针引用。节点拷贝算法由于在拷贝过程中，就可以进行内存整理，所以不会再有内存碎片的问题，同时也不需要再专门做一次内存压缩。，而它最大的缺点在于需要双倍的空间

c：老年代： 

如果新生代在若干次清理（可以进行设置）中依然存活，则移入老年代，有的内存占用比较大的直接进入老年代。老年代使用标记清理算法，清理的频率比较低。 

标记清理算法：对所有存活对象进行一次全局遍历来确定哪些对象可以回收，遍历的过程从根出发，找到所有可达对象，除此之外，其它不可达的对象就是垃圾对象，可被回收。整个过程分为两个阶段：标记阶段找到所有存活对象；清除阶段清除所有垃圾对象。 

相比较引用计数算法，标记-清除算法可以非常自然的处理环形引用问题，另外在创建对象和销毁对象时时少了操作引用计数值的开销。 

它的缺点在于标记-清除算法是一种“停止-启动”算法，在垃圾回收器运行过程中，应用程序必须暂时停止。另外，标记-清除算法在标记阶段需要遍历所有的存活对象，会造成一定的开销，在清除阶段，清除垃圾对象后会造成大量的内存碎片。

 

5、触发GC（Garbage Collector）的条件

Minor GC触发条件：当Eden区满时，触发Minor GC。

Full GC触发条件：

（1）调用System.gc时，系统建议执行Full GC，但是不必然执行

（2）老年代空间不足

（3）方法去空间不足

（4）通过Minor GC后进入老年代的平均大小大于老年代的可用内存

（5）由Eden区、From Space区向To Space区复制时，对象大小大于To Space可用内存，则把该对象转存到老年代，且老年代的可用内存小于该对象大小

 

6、jvm中一次完整的GC流程（从ygc到fgc）是怎样的，重点讲讲对象如何晋升到老年代等

(1)、Eden区满时，进行Minor GC，当Eden和一个Survivor区中依然存活的对象无法放入到Survivor中，则通过分配担保机制提前转移到老年代中。 

(2)、若对象体积太大, 新生代无法容纳这个对象，-XX:PretenureSizeThreshold即对象的大小大于此值, 就会绕过新生代, 直接在老年代分配, 此参数只对Serial及ParNew两款收集器有效。

(3)、长期存活的对象将进入老年代。

        虚拟机对每个对象定义了一个对象年龄（Age）计数器。当年龄增加到一定的临界值时，就会晋升到老年代中，该临界值由参数：-XX:MaxTenuringThreshold来设置。

        如果对象在Eden出生并在第一次发生MinorGC时仍然存活，并且能够被Survivor中所容纳的话，则该对象会被移动到Survivor中，并且设Age=1；以后每经历一次Minor GC，该对象还存活的话Age=Age+1。

(4)、动态对象年龄判定。

        虚拟机并不总是要求对象的年龄必须达到MaxTenuringThreshold才能晋升到老年代，如果在Survivor区中相同年龄（设年龄为age）的对象的所有大小之和超过Survivor空间的一半，年龄大于或等于该年龄（age）的对象就可以直接进入老年代，无需等到MaxTenuringThreshold中要求的年龄。

 

7、Eden和Survivor的比例分配

默认比例8:1。 大部分对象都是朝生夕死。 复制算法的基本思想就是将内存分为两块，每次只用其中一块，当这一块内存用完，就将还活着的对象复制到另外一块上面。复制算法不会产生内存碎片。 

有关年轻代的JVM参数

1)-XX:NewSize和-XX:MaxNewSize

用于设置年轻代的大小，建议设为整个堆大小的1/3或者1/4,两个值设为一样大。

2)-XX:SurvivorRatio

用于设置Eden和其中一个Survivor的比值，这个值也比较重要。

3)-XX:+PrintTenuringDistribution

这个参数用于显示每次Minor GC时Survivor区中各个年龄段的对象的大小。

4).-XX:InitialTenuringThreshol和-XX:MaxTenuringThreshold

用于设置晋升到老年代的对象年龄的最小值和最大值，每个对象在坚持过一次Minor GC之后，年龄就加1。

 

8、深入分析了Classloader，双亲委派机制 

ClassLoader：类加载器（class loader）用来加载 Java 类到 Java 虚拟机中。Java 源程序（.java 文件）在经过 Java 编译器编译之后就被转换成 Java 字节代码（.class 文件）。类加载器负责读取 Java 字节代码，并转换成 java.lang.Class 类的一个实例。 

双亲委派机制：某个特定的类加载器在接到加载类的请求时，首先将加载任务委托给父类加载器，依次递归，如果父类加载器可以完成类加载任务，就成功返回；只有父类加载器无法完成此加载任务时，才自己去加载。

 

9、g1和cms区别=吞吐量优先和响应优先的垃圾收集器选择

CMS收集器：

一款以获取最短回收停顿时间为目标的收集器，是基于“标记-清除”算法实现的，分为4个步骤：初始标记、并发标记、重新标记、并发清除。 

G1收集器：

面向服务端应用的垃圾收集器，过程：初始标记；并发标记；最终标记；筛选回收。整体上看是“标记-整理”，局部看是“复制”，不会产生内存碎片。 

吞吐量优先的并行收集器：

以到达一定的吞吐量为目标，适用于科学技术和后台处理等。 

响应时间优先的并发收集器：

保证系统的响应时间，减少垃圾收集时的停顿时间。适用于应用服务器、电信领域等。

 

10、说一说你对环境变量classpath的理解？如果一个类不在classpath下，为什么会抛出ClassNotFoundException异常，如果在不改变这个类路径的前期下，怎样才能正确加载这个类？

classpath是javac编译器的一个环境变量。它的作用与import、package关键字有关。package的所在位置，就是设置CLASSPATH当编译器面对import packag这个语句时，它先会查找CLASSPATH所指定的目录，并检视子目录java/util是否存在，然后找出名称吻合的已编译文件（.class文件）。如果没有找到就会报错！ 

如果要正确加载这个类，需要动态加载包。

 

11、tomcat结构，类加载器流程 

目录结构： 

• /bin：存放windows或Linux平台上启动和关闭Tomcat的脚本文件 

• /conf：存放Tomcat服务器的各种全局配置文件，其中最重要的是server.xml和web.xml 

• /doc：存放Tomcat文档 

• /server：包含三个子目录：classes、lib和webapps 

• /server/lib：存放Tomcat服务器所需的各种JAR文件 

• /server/webapps：存放Tomcat自带的两个WEB应用admin应用和 manager应用 

• /common/lib：存放Tomcat服务器以及所有web应用都可以访问的jar文件 

• /shared/lib：存放所有web应用都可以访问的jar文件（但是不能被Tomcat服务器访问） 

• /logs：存放Tomcat执行时的日志文件 

• /src：存放Tomcat的源代码 

• /webapps：Tomcat的主要Web发布目录，默认情况下把Web应用文件放于此目录 

• /work：存放JSP编译后产生的class文件 

 

12、Java 8的内存分代改进

从永久代到元空间，在小范围自动扩展永生代避免溢出

 

13、JVM垃圾回收机制

分代垃圾回收机制：

不同的对象生命周期不同。把不同生命周期的对象放在不同代上，不同代上采用最合适它的垃圾回收方式进行回收。 

JVM中共划分为三个代：年轻代、年老代和持久代， 

年轻代：存放所有新生成的对象； 

年老代：在年轻代中经历了N次垃圾回收仍然存活的对象，将被放到年老代中，故都是一些生命周期较长的对象； 

持久代：用于存放静态文件，如Java类、方法等。 

新生代的垃圾收集器命名为“minor gc”，老生代的GC命名为”Full Gc 或者Major GC”。

 

14、简述几种垃圾收集器

1、Serial收集器曾经是虚拟机新生代收集的唯一选择，是一个单线程的收集器，在进行收集垃圾时，必须stop the world，它是虚拟机运行在Client模式下的默认新生代收集器。

2、Serial Old是Serial收集器的老年代版本，同样是单线程收集器，使用标记整理算法。

3、ParNew收集器是Serial收集器的多线程版本，许多运行在Server模式下的虚拟机中首选的新生代收集器，除Serial外，只有它能与CMS收集器配合工作。

4、Parallel Scavenge收集器也是新生代收集器，使用复制算法又是并行的多线程收集器，它的目标是达到一个可控制的运行用户代码跟（运行用户代码+垃圾收集时间）的百分比值。

5、Parallel Old收集器是Parallel Scavenge收集器的老年代版本，使用多线程和标记整理算法。 

6、Concurrent Mark Sweep 收集器是一种以获得最短回收停顿时间为目标的收集器，基于标记清除算法。

过程如下：初始标记，并发标记，重新标记，并发清除，优点是并发收集，低停顿，缺点是对CPU资源非常敏感，无法处理浮动垃圾，收集结束会产生大量空间碎片。

7、G1收集器是基于标记整理算法实现的，不会产生空间碎片，可以精确地控制停顿，将堆划分为多个大小固定的独立区域，并跟踪这些区域的垃圾堆积程度，在后台维护一个优先列表，每次根据允许的收集时间，优先回收垃圾最多的区域（Garbage First）。

 

 

15、JVM内存分哪几个区，每个区的作用是什么?

jvm内存主要分为五个部分：方法区，java堆，java栈，程序计数器，本地方法栈。

方法区（永久代，线程共享）：

存储被虚拟机加载的类信息，常量，静态常量，静态方法，运行时常量池等。

（1）用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据。

（2）Sun HotSpot虚拟机把方法区叫做永久代（Permanent Generation），方法区中最重要的部分是运行时常量池（运行时常量池是方法区的一部分，自然受到方法区内存的限制，当常量池无法再申请到内存时就会抛出OutOfMemoryError异常。）。

 

java堆（线程共享）：

存放所有new出来的东西。

（1）堆是java虚拟机所管理的内存区域中最大的一块，java堆是被所有线程共享的内存区域，在java虚拟机启动时创建，堆内存的唯一目的就是存放对象实例，几乎所有的对象实例都在堆内存分配空间。

（2）堆是GC管理的主要区域，从垃圾回收的角度看，由于现在的垃圾收集器都是采用的分代收集算法，因此java堆还可以初步细分为新生代和老年代。

（3）Java虚拟机规定，堆可以处于物理上不连续的内存空间中，只要逻辑上连续的即可。在实现上既可以是固定的，也可以是可动态扩展的。如果在堆内存没有完成实例分配，并且堆大小也无法扩展，就会抛出OutOfMemoryError异常。

 

java栈（线程私有方法级）：

为虚拟机执使用到的方法服务。每个方法被调用的时候都会创建一个栈帧，用于存储局部变量表、操作栈、动态链接、方法出口等信息。局部变量表存放的是：编译期可知的基本数据类型、对象引用类型。每个方法被调用直到执行完成的过程，就对应着一个栈帧在虚拟机中从入栈到出栈的过程。

在Java虚拟机规范中，对这个区域规定了两种异常情况：

（1） 如果线程请求的栈深度太深，超出了虚拟机所允许的深度，就会出现StackOverFlowError（比如无限递归。因为每一层栈帧都占用一定空间，而 Xss 规定了栈的最大空间，超出这个值就会报错）。

（2） 虚拟机栈可以动态扩展，如果扩展到无法申请足够的内存空间，会出现OOM。

 

程序计数器（线程私有）：

保证线程切换后能恢复到原来的位置。在线程创建时创建，指向下一条指令的地址，执行本地方法时，其值为undefined。说的通俗一点，我们知道，Java是支持多线程的，程序先去执行A线程，执行到一半，然后就去执行B线程，然后又跑回来接着执行A线程，那程序是怎么记住A线程已经执行到哪里了呢？这就需要程序计数器了。因此，为了线程切换后能够恢复到正确的执行位置，每条线程都有一个独立的程序计数器，这块儿属于“线程私有”的内存。

 

本地方法栈（线程私有）：

为虚拟机执使用到的Native方法服务。

（1）本地方法栈与java虚拟机栈作用非常类似，其区别是：java虚拟机栈是为虚拟机执行java方法服务的，而本地方法栈则为虚拟机执使用到的Native方法服务。

（2）Java虚拟机没有对本地方法栈的使用和数据结构做强制规定，Sun HotSpot虚拟机就把java虚拟机栈和本地方法栈合二为一。

（3）本地方法栈也会抛出StackOverFlowError和OutOfMemoryError。

 

16、java内存模型

java内存模型(JMM)是线程间通信的控制机制.JMM定义了主内存和线程之间抽象关系。线程之间的共享变量存储在主内存（main memory）中，每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。

从上图来看，线程A与线程B之间如要通信的话，必须要经历下面2个步骤：

1. 首先，线程A把本地内存A中更新过的共享变量刷新到主内存中去。

2. 然后，线程B到主内存中去读取线程A之前已更新过的共享变量。

 

17、java中垃圾收集的方法有哪些?

这是垃圾收集算法中最基础的，根据名字就可以知道，它的思想就是标记哪些要被回收的对象，然后统一回收。这种方法很简单，但是会有两个主要问题：1.效率不高，标记和清除的效率都很低；2.会产生大量不连续的内存碎片，导致以后程序在分配较大的对象时，由于没有充足的连续内存而提前触发一次GC动作。

复制算法:

为了解决效率问题，复制算法将可用内存按容量划分为相等的两部分，然后每次只使用其中的一块，当一块内存用完时，就将还存活的对象复制到第二块内存上，然后一次性清楚完第一块内存，再将第二块上的对象复制到第一块。但是这种方式，内存的代价太高，每次基本上都要浪费一般的内存。

于是将该算法进行了改进，内存区域不再是按照1：1去划分，而是将内存划分为8:1:1三部分，较大那份内存交Eden区，其余是两块较小的内存区叫Survior区。每次都会优先使用Eden区，若Eden区满，就将对象复制到第二块内存区上，然后清除Eden区，如果此时存活的对象太多，以至于Survivor不够时，会将这些对象通过分配担保机制复制到老年代中。(java堆又分为新生代和老年代)

标记-整理

该算法主要是为了解决标记-清除，产生大量内存碎片的问题；当对象存活率较高时，也解决了复制算法的效率问题。它的不同之处就是在清除对象的时候现将可回收对象移动到一端，然后清除掉端边界以外的对象，这样就不会产生内存碎片了。

分代收集 

现在的虚拟机垃圾收集大多采用这种方式，它根据对象的生存周期，将堆分为新生代和老年代。在新生代中，由于对象生存期短，每次回收都会有大量对象死去，那么这时就采用复制算法。老年代里的对象存活率较高，没有额外的空间进行分配担保，所以可以使用标记-整理 或者 标记-清除。

 

18、Java类加载过程?

1、加载：这个很简单，程序运行之前jvm会把编译完成的.class二进制文件加载到内存，供程序使用，用到的就是类加载器classLoader ，这里也可以看出java程序的运行并不是直接依   靠底层的操作系统，而是基于jvm虚拟机。如果没有类加载器，java文件就只是磁盘中的一个普通文件。

2、连接：连接是很重要的一步，过程比较复杂，分为三步  验证  》准备  》解析  　　

　　验证：确保类加载的正确性。一般情况由javac编译的class文件是不会有问题的，但是可能有人的class文件是自己通过其他方式编译出来的，这就很有可能不符合jvm的编 译规则，这一步就是要过滤掉这部分不合法文件　

　　准备：为类的静态变量分配内存，将其初始化为默认值 。我们都知道静态变量是可以不用我们手动赋值的，它自然会有一个初始值 比如int 类型的初始值就是0 ；boolean类型初始值为false，引用类型的初始值为null 。 这里注意，只是为静态变量分配内存，此时是没有对象实例的　

　　解析：把类中的符号引用转化为直接引用。解释一下符号引用和直接引用。比如在方法A中使用方法B，A（）{B（）；}，这里的B（）就是符号引用，初学java时我们都是知道这是java的引用，以为B指向B方法的内存地址，但是这是不完整的，这里的B只是一个符号引用，它对于方法的调用没有太多的实际意义，可以这么认为，他就是给程序员看的一个标志，让程序员知道，这个方法可以这么调用，但是B方法实际调用时是通过一个指针指向B方法的内存地址，这个指针才是真正负责方法调用，他就是直接引用。

3、初始化：为类的静态变量赋予正确的初始值，上述的准备阶段为静态变量赋予的是虚拟机默认的初始值，此处赋予的才是程序编写者为变量分配的真正的初始值

类加载过程分为：类的主动引用和类的被动引用

1、类的主动引用（一定会发生类的初始化）

• new一个类的对象
• 调用类的静态成员（除了final常量）和静态方法
• 使用java.lang.reflect包的方法对类进行反射调用
• 当初始化一个类，如果其父类没有被初始化，则先初始化他的父类
• 当要执行某个程序时，一定先启动main方法所在的类

2、类的被动引用（不会发生类的初始化）

• 当访问一个静态变量时，只有真正生命这个静态变量的类才会被初始化（通过子类引用父类的静态变量，不会导致子类初始化）
• 通过数组定义类应用，不会触发此类的初始化  A[] a = new A[10];
• 引用常量(final类型)不会触发此类的初始化（常量在编译阶段就存入调用类的常量池中了）

 

19、JVM几种内存溢出异常及解决

虚拟机主要的几种异常是OutOfMemoryError异常和虚拟机栈和本地方法栈溢出，以及运行时常量池溢出等。

（1）OutOfMemoryError异常

除了程序计数器外，虚拟机内存的其他几个运行时区域都有发生OutOfMemoryError(OOM)异常的可能，java堆用于存储对象实例，我们只要不断的创建对象，并且保证GC Roots到对象之间有可达路径来避免垃圾回收机制清除这些对象，就会在对象数量达到最大堆容量限制后产生内存溢出异常。

出现这种异常，一般手段是先通过内存映像分析工具(如Eclipse Memory Analyzer)对dump出来的堆转存快照进行分析，重点是确认内存中的对象是否是必要的，先分清是因为内存泄漏(Memory Leak)还是内存溢出(Memory Overflow)。

如果是内存泄漏，可进一步通过工具查看泄漏对象到GC Roots的引用链。于是就能找到泄漏对象时通过怎样的路径与GC Roots相关联并导致垃圾收集器无法自动回收。

如果不存在泄漏，那就应该检查虚拟机的参数(-Xmx与-Xms)的设置是否适当。

（2）虚拟机栈和本地方法栈溢出

如果线程请求的栈深度大于虚拟机所允许的最大深度，将抛出StackOverflowError异常。

如果虚拟机在扩展栈时无法申请到足够的内存空间，则抛出OutOfMemoryError异常

这里需要注意每个线程分配到的栈容量越大，可以建立的线程数就越少，建立线程时候就越容易耗尽剩余内存。

按虚拟机默认参数，栈深度在大多数情况下达到1000~2000完全没问题，对于正常方法调用（包括递归），这个深度应该完全够用；

但如果是建立过多线程导致内存溢出，在不能减少线程数或者更换X64位虚拟机的情况下，就只能通过减少最大堆和减少栈容量来换取更多的线程

（3）方法区和运行时常量区溢出

java.lang.OutOfMemoryError: PermGen space

运行时常量池溢出（HotSpot虚拟机中的永久代），如果要向运行时常量池中添加内容，最简单的做法就是使用String.intern()这个Native方法。

运行时常量池溢出（HotSpot虚拟机中的永久代），如果要向运行时常量池中添加内容，最简单的做法就是使用String.intern()这个Native方法。该方法的作用是如果池中已经包含一个等于此String的字符串，则返回代表池中这个字符串的String对象；否则，将此String对象包含的字符串添加到常量池中，并且返回此String对象的引用。由于常量池分配在方法区内，我们可以通过-XX:PermSize和-XX:MaxPermSize限制方法区的大小，从而间接限制其中常量池的容量。

 

20、JVM 出现 fullGC 很频繁，怎么去线上排查问题？

可能原有有如下三个：具体问题得进行内存分析

• 年轻代空间不足
• per Gen（永久代）空间满
• CMS GC时出现promotion failed和concurrent mode failure

 

21、类加载为什么要使用双亲委派模式，有没有什么场景是打破了这个模式？

为什么需要双亲委派模型？

为什么需要双亲委派模型呢？假设没有双亲委派模型，试想一个场景：

黑客自定义一个java.lang.String类，该String类具有系统的String类一样的功能，只是在某个函数稍作修改。比如equals函数，这个函数经常使用，如果在这这个函数中，黑客加入一些“病毒代码”。并且通过自定义类加载器加入到JVM中。此时，如果没有双亲委派模型，那么JVM就可能误以为黑客自定义的java.lang.String类是系统的String类，导致“病毒代码”被执行。

而有了双亲委派模型，黑客自定义的java.lang.String类永远都不会被加载进内存。因为首先是最顶端的类加载器加载系统的java.lang.String类，最终自定义的类加载器无法加载java.lang.String类。

或许你会想，我在自定义的类加载器里面强制加载自定义的java.lang.String类，不去通过调用父加载器不就好了吗?确实，这样是可行。但是，在JVM中，判断一个对象是否是某个类型时，如果该对象的实际类型与待比较的类型的类加载器不同，那么会返回false。

举个简单例子：

ClassLoader1、ClassLoader2都加载java.lang.String类，对应Class1、Class2对象。那么Class1对象不属于ClassLoad2对象加载的java.lang.String类型。

如何打破双亲委派模型？

打破双亲委派机制则不仅要继承ClassLoader类，还要重写loadClass和findClass方法，如下例子：

①定义Test类。

public class Test {   public Test(){     System.out.println(this.getClass().getClassLoader().toString());   } }

②重新定义一个继承ClassLoader的TestClassLoaderN类，这个类与前面的TestClassLoader类很相似，但它除了重写findClass方法外还重写了loadClass方法，默认的loadClass方法是实现了双亲委派机制的逻辑，即会先让父类加载器加载，当无法加载时才由自己加载。这里为了破坏双亲委派机制必须重写loadClass方法，即这里先尝试交由System类加载器加载，加载失败才会由自己加载。它并没有优先交给父类加载器，这就打破了双亲委派机制。

public class TestClassLoaderN extends ClassLoader {



  private String name;



  public TestClassLoaderN(ClassLoader parent, String name) {

    super(parent);

    this.name = name;

  }



  @Override

  public String toString() {

    return this.name;

  }



  @Override

  public Class loadClass(String name) throws ClassNotFoundException {

    Class clazz = null;

    ClassLoader system = getSystemClassLoader();

    try {

      clazz = system.loadClass(name);

    } catch (Exception e) {

      // ignore

    }

    if (clazz != null)

      return clazz;

    clazz = findClass(name);

    return clazz;

  }



  @Override

  public Class findClass(String name) {



    InputStream is = null;

    byte[] data = null;

    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    try {

      is = new FileInputStream(new File("d:/Test.class"));

      int c = 0;

      while (-1 != (c = is.read())) {

        baos.write(c);

      }

      data = baos.toByteArray();

    } catch (Exception e) {

      e.printStackTrace();

    } finally {

      try {

        is.close();

        baos.close();

      } catch (IOException e) {

        e.printStackTrace();

      }

    }

    return this.defineClass(name, data, 0, data.length);

  }



  public static void main(String[] args) {

    TestClassLoaderN loader = new TestClassLoaderN(

        TestClassLoaderN.class.getClassLoader(), "TestLoaderN");

    Class clazz;

    try {

      clazz = loader.loadClass("test.classloader.Test");

      Object object = clazz.newInstance();

    } catch (Exception e) {

      e.printStackTrace();

    }

  }



}

 

22、虚拟机性能监控与故障处理工具

定位问题

• GC日志
• 堆转储快照（heapdump/hprof文件）
• 线程快照（threaddump/javacore文件）
• 运行日志
• 异常堆栈

分析依据的工具

• jps：显示指定系统内的所有JVM进程
• jstat：收集JVM各方面的运行数据
• jinfo：显示JVM配置信息
• jmap：形成堆转储快照（heapdump文件）
• jhat：分析heapdump文件
• jstack：显示JVM的线程快照
• jconsole
• visualVM

 

23、分派：静态分派（重载）与动态分派（重写）

这里所谓的分派指的是在Java中对方法的调用。Java中有三大特性：封装、继承和多态。分派是多态性的体现，Java虚拟机底层提供了我们开发中“重写”和“重载”的底层实现。其中重载属于静态分派，而重写则是动态分派的过程。除了使用分派的方式对方法进行调用之外，还可以使用解析调用，解析调用是在编译期间就已经确定了，在类装载的解析阶段就会把符号引用转化为直接引用，不会延迟到运行期间再去完成。而分派调用则既可以是静态的也可以是动态（就是这里的静态分派和动态分派）的。