1. 什么是jvm？

是计算机设备的一个规范，jvm屏蔽了与具体操作系统的具体的信息。使Java程序只是需要  

生成java虚拟机上运行的目标代码(字节码)，就可以在多种平台上可以不加修改就可以运行。实际上
jvm在执行字节码最终还是解释成具体平台的机器码指令来执行的。

2. JRE/JDK/JVM是什么关系？

JRE:JavaRuntimeEnvironment.Java运行环境。所有程序需要在jre下才能运行。普通用户只需要运行已开发好的java程序，安装jre即可。

jdk：JavaDevelopmentKit。是开发者用来编译，调试java程序的开发工具包。安装jdk的时候，同时也会在目录下有一个jre的目录，用于存放jre文件。

jvm：JavaVirtualMachine.Java虚拟机。是jre的一部分。

3. JVM的原理？

java编译器只要面向JVM,生成JVM能理解的代码或者是字节码文件。Java源文件经过编译成字节码程序，通过JVM将每一条指令翻译成不同平台的机器码，通过特定的

平台运行。

4. JVM的体系结构(----包含7个知识点----：①类装载器ClassLoader。②Native Interface 本地接口。③Native Method Stack 本地方法栈。④程序计数器 （PC寄存器）。⑤方法区 Method Area。⑥栈 。 ⑦堆、栈、方法区 三者的关系)

4.1 类加载器（4个知识点，①概念，②种类(3种系统自带，1种自定义)，③双亲委派机制，④沙箱安全机制）

4.1.1 类装载器的概念

负责加载class文件，class文件在文件开头有特定的文件标识 ，将class文件字节码内容加载到内存中，并将这些内容转换成方法区中的运行时数据结构

并且ClassLoader只负责class文件的加载，至于它是否可以运行，则由Execution Engine决定。

解释：  

Car.class  是由 .java 文件 经过编译而得来的 .class文件，存在本地磁盘  

ClassLoader: 类转载器，作用就是加载并初始化 .class文件 ，得到真正的 Class 类，即模板  （此处不明白则带着疑问继续往下看，为什么叫模板）

Car Class : 由 Car.class 字节码文件，通过ClassLoader 加载并初始化而得，
那么此时 这个 Car 就是当前类的模板，这个Car Class 模板就存在 【方法区】

car1,car2,car3 : 是由Car模板经过实例化而得，即 new出来的 --> Car car1 = new Car() , Car car2 = new Car() ,Car car3 = new Car() ,  

因此可知，由一个模板，可以得到多个实例对象，即模板一个，实例多个  
 
所以，拿car1举例，car1.getClass 可以得到其模板Car 类，Car.getClassLoader() 可得到其装载器  

4.1.2 类装载器的种类

1.2.1 虚拟机自带的加载器  
   ①  启动类加载器 也叫根加载器 （Bootstrap）  ,由C++编写  ，程序中自带的类， 存储在$JAVAHOME/jre/lib/rt.jar中，如object类等
   ②  扩展类加载器 （Extension）  ，Java 编写 ，在我们平时看到的类路径中，凡是以javax 开头的，都是拓展包，存储在$JAVAHOME/jre/lib/ext/*.jar 中 
   ③  应用程序类加载器  （AppClassLoader），即平时程序中自定义的类  new出来的  

  Java也叫系统类加载器，加载当前应用的classpath的所有的类

1.2.2 用户自定义加载器  
 Java.lang.ClassLoader的子类，用户可以定制类的加载方式，即如果你的程序有特殊的需求，你也可以自定义你的类加载器的加载方式  
 
 ，进入ClassLoader的源码，其为抽象类，因此在你定制化开发的时候，需要你定义自己的加载器类来继承ClassLoader抽象类即可，  
 
 即 MyClassLoader extends ClassLoader

所以，Java 的类的加载机制，永远是从 启动类加载器 --> 拓展类加载器 --> 应用程序类加载器 这样的一个顺序进行加载

4.1.3 类装载器的双亲委派机制

先举一个栗子，来说明下啥叫双亲委派，比如 有一个类叫 A.java ,当要使用A类时，类加载器要先去

启动类加载器（Bootstrap）中去找，如果找到就使用启动类加载器中的A类，不继续往下执行，但是如果找不到，则依次下放，去 拓展类加载器

中找，同理找到就用，找不到就继续下放，再去 应用程序类加载器中找，找到就用，此时找不到就会报classNotFund Exception的异常。

概念：当一个类收到类加载请求，它首先不会尝试自己去加载这个类，而是先把这个请求委派给父类去完成，每一个层次类加载器都是如此，因此所有的类加

载请求都是应该传到启动类加载器中的，只有当其父类加载器自己无法完成这个请求的时候（在他的加载路径下没有找到所需加载的Class）,子类加载器才会尝试自己去加载。

采用双亲委派的一个好处就是比如加载位于rt.jar包中的类java.lang.Object，不管是哪个加载器加载这个类，最终都是会委托给顶层的启动类加载器进行加载，

这样就保证了使用不同的类加载器最终得到的都是同一个Object对象。

4.1.4 类装载器沙箱安全机制

通过双亲委派机制，类的加载永远都是从 启动类加载器开始，依次下放，保证你所写的代码，不会污染Java自带的源代码，所以出现了双亲委派机制，保证了沙箱安全

4.2 Native Interface 本地接口

native ：在Java中是一个关键字，有声明，无实现。
    
以线程为例，不要以为线程是属于Java的一个东西，其实它是属于操作系统底层的，Java中通过Thread类的start() 类启动一个线程.  

进入Thread的start()的源码，你会看到虽然调用的是start(),但其实调用的start0()这个方法,  

最终是由 private native void start0(); 这段代码去跟底层做了交互实现，有声明，无实现，Java到此交由系统去处理了。

拓展：

这里引申个题外知识哈，即我new 一个线程，当我执行 thread.start() ；这个方法之后，是不是会立即执行这个线程呢？  
  
  答案就是不一定，因为当你创建一个线程，调用start()方法后，是将线程从初始化状态变为就绪状态，而真正的执行，是要等cpu来进行调度，你才能执行，否则你就跟那就绪着，千万别信誓旦旦的说，肯定会立即执行，还是建议看一下 操作系统的课本。


    本地接口的作用是融合不同的编程语言为Java所用，它的初衷是想融合C/C++ 程序，Java诞生之初，正式C/C++ 盛行之时，因此，Java要想立足，则必须要调用C/C++程序（打个比方：微某信和抖某音，起初阿抖想分享视频给阿音某好友，
    
    直接点分享就过去了，但是后来被阿音给禁止了，当初Java也是一样，你要想使用我的某些东西，那你就得给我整点“保护费”啊），
    
    于是在内存中专门开辟了一块区域处理标记为native的代码，它的具体做法就是 Native Method Stack 中登记 native 方法，
    
    在 Exection Engine 执行时加载 native libraies。  
    目前该方法使用的越来越少，除非是与硬件有关的应用，比如通过Java程序驱动打印机或者Java系统管理的生产设备，
    
    在企业级应用中比较少见，因为现在的异构领域间的通信很发达，比如可以使用Socket通讯，也可以使用Web Service等等，不多做介绍。。。。 

4.3Native Method Stack 本地方法栈

它的具体做法是 Native Method Stack 中登记 native 方法，在 Execution Engine 执行时加载本地方法库。

4.4程序计数器 （PC寄存器）

记录了方法之间的调用和执行情况，类似班级的值日表，用来存储指向下一条指令的地址，也即将要执行的指令代码

每个线程都有一个程序计数器，是线程私有的，就是一个指针，指向方法区中的方法字节码（用来存储指向下一条指令的地址，也即将要执行的指令代码。  
建议看一下【计算机操作系统】这本书，其实不光有pc,还有时间片的轮转，这里不多做介绍），有执行引擎读取下一条指令，是一个非常小的内存空间，

几乎可以忽略不计。

这块存储区域很小，他是当前线程所执行的字节码的行号指示器，字节码解释器通过改变这个计数器的值来选取下一条需要执行的字节码指令。

如果执行的是一个Native方法，那这个计数器就是空的，因为native已经不属于Java的范畴了 。

用以完成分支、循环、跳转、异常处理、线程恢复等基础功能。不会发生内存溢出（OutOfMemory = OOM）错误。  

4.5方法区 Method Area

4.5.1 供各线程 共享 的运行时内存区域。----存储了每一个类的结构信息---- （即上面所提到的模板）。

例如：运行时常量池（Runtime Constant Pool）、字段 和 方法数据、构造函数和普通方法的字节码内容。

4.5.2 方法区就是一个规范，在不同的虚拟机里实现是不一样的，最典型的就是 永久代（PermGen space） 和 元空间 （Metaspace）

永久代：JDK1.7

元空间：JDK1.8

两者都不存在方法区中，就像上面所讲，方法区存的是模板，而永久代和元空间是这套模板的实例，后面在堆中讨论
所以，实例变量存储在堆内存中，和方法区无关。

4.6栈

记住 ： 栈管运行，堆管存储

### 4.6.1 栈也叫栈内存，主管Java程序的运行，是在线程创建时创建，他的生命周期是跟随线程的生命周期，线程结束那么栈内存也就随之释放， 对于栈来说不存在垃圾回收问题 ，只要线程已结束该栈就over了，是线程私有的。8种基本类型的变量 + 对象的引用变量 + 实例方法都是在函数的占内存中分配。

4.6.2 栈存储什么？

        栈帧中主要保存 3 类数据 ： （何为栈帧：即Java中的方法，只是在jvm中叫做栈帧）
        - ① 本地变量 （Local Variables） : 入参和出参 以及方法内的变量；
        - ② 栈操作 （Operand Stack） : 记录出栈 和 入栈的操作；（可理解为pc寄存器的指针）
        - ③ 栈帧数据 （Frame Data） : 包括类文件、方法等。

栈的运行原理： 栈中的数据都是以栈帧 （Stack Frame） 的格式存在，栈帧是一个内存区块，是一个有关方法和运行期数据的数据集，

        当一个方法A被调用时就产生了栈帧 F1,并被压入到栈中，
        A方法又调用 B方法，于是产生栈帧F2 ,也被压入栈，
        B方法又调用 C方法， 于是产生栈帧F3，也被压入栈 
        ……
        执行完毕后，先弹出F3栈帧，再弹出 F2栈帧，再弹出 F1栈帧 …… 

    遵循 “先进后出” / “后进先出” 原则。

        每个方法执行的同时都会创建一个栈帧，用于存储局部变量表，操作数据栈，动态连接、方法出口等信息，每一个方法从调用直至执行完毕的过程，就对应着一个栈帧在虚拟机中入栈到出栈的操作过程  
        栈的大小和具体jvm的实现有关，通常在 256K ~ 756K 之间，约等于 1Mb左右。

5：对象“已死”的判定算法

由于程序计数器、Java虚拟机栈、本地方法栈都是线程独享，其占用的内存也是随线程生而生、随线程结束而回收。而Java堆和方法区则不同，线程共享，是GC的所关注的部分。

在堆中几乎存在着所有对象，GC之前需要考虑哪些对象还活着不能回收，哪些对象已经死去可以回收。

有两种算法可以判定对象是否存活：

1.）引用计数算法：给对象中添加一个引用计数器，每当一个地方应用了对象，计数器加1；当引用失效，计数器减1；当计数器为0表示该对象已死、可回收。但是它很难解决两个对象之间相互循环引用的情况。

2.）可达性分析算法：通过一系列称为“GC Roots”的对象作为起点，从这些节点开始向下搜索，搜索所走过的路径称为引用链，当一个对象到GC Roots没有任何引用链相连（即对象到GC Roots不可达），则证明此对象已死、可回收。Java中可以作为GC Roots的对象包括：虚拟机栈中引用的对象、本地方法栈中Native方法引用的对象、方法区静态属性引用的对象、方法区常量引用的对象。

在主流的商用程序语言（如我们的Java）的主流实现中，都是通过可达性分析算法来判定对象是否存活的。

7：JVM垃圾回收

GC (Garbage Collection)的基本原理：将内存中不再被使用的对象进行回收，GC中用于回收的方法称为收集器，由于GC需要消耗一些资源和时间，Java在对对象的生命周期特征进行分析后，按照新生代、旧生代的方式来对对象进行收集，以尽可能的缩短GC对应用造成的暂停

（1）对新生代的对象的收集称为minor GC；

（2）对旧生代的对象的收集称为Full GC；

（3）程序中主动调用System.gc()强制执行的GC为Full GC。

不同的对象引用类型， GC会采用不同的方法进行回收，JVM对象的引用分为了四种类型：

（1）强引用：默认情况下，对象采用的均为强引用（这个对象的实例没有其他对象引用，GC时才会被回收）

（2）软引用：软引用是Java中提供的一种比较适合于缓存场景的应用（只有在内存不够用的情况下才会被GC）

（3）弱引用：在GC时一定会被GC回收

（4）虚引用：由于虚引用只是用来得知对象是否被GC

8：垃圾收集算法

8.1、标记-清除算法

最基础的算法，分标记和清除两个阶段：首先标记处所需要回收的对象，在标记完成后统一回收所有被标记的对象。

它有两点不足：一个效率问题，标记和清除过程都效率不高；一个是空间问题，标记清除之后会产生大量不连续的内存碎片（类似于我们电脑的磁盘碎片），空间碎片太多导致需要分配大对象时无法找到足够的连续内存而不得不提前触发另一次垃圾回收动作。

---------------------------------------------我是分割线-------------------------------------------------

8.2、复制算法

为了解决效率问题，出现了“复制”算法，他将可用内存按容量划分为大小相等的两块，

每次只需要使用其中一块。当一块内存用完了，将还存活的对象复制到另一块上面，

然后再把刚刚用完的内存空间一次清理掉。这样就解决了内存碎片问题，但是代价就是可以用内容就缩小为原来的一半。

8.3、标记-整理算法

复制算法在对象存活率较高时就会进行频繁的复制操作，效率将降低。因此又有了标记-整理算法，

标记过程同标记-清除算法，但是在后续步骤不是直接对对象进行清理，而是让所有存活的对象都向一侧移动，然后直接清理掉端边界以外的内存。

8.4、分代收集算法

当前商业虚拟机的GC都是采用分代收集算法，这种算法并没有什么新的思想，而是根据对象存活周期的不同将堆分为：新生代和老年代，

方法区称为永久代（在新的版本中已经将永久代废弃，引入了元空间的概念，永久代使用的是JVM内存而元空间直接使用物理内存）。

这样就可以根据各个年代的特点采用不同的收集算法。

新生代中的对象“朝生夕死”，每次GC时都会有大量对象死去，少量存活，使用复制算法。新生代又分为Eden区和Survivor区（Survivor from、Survivor to），大小比例默认为8:1:1。

老年代中的对象因为对象存活率高、没有额外空间进行分配担保，就使用标记-清除或标记-整理算法。

新产生的对象优先进去Eden区，当Eden区满了之后再使用Survivor from，当Survivor from 也满了之后就进行Minor GC（新生代GC），将Eden和Survivor

from中存活的对象copy进入Survivor to，然后清空Eden和Survivor from，这个时候原来的Survivor from成了新的Survivor to，原来的Survivor to成了新的Survivor

from。复制的时候，如果Survivor to 无法容纳全部存活的对象，则根据老年代的分配担保（类似于银行的贷款担保）将对象copy进去老年代，如果老年代也无法容

纳，则进行Full GC（老年代GC）。

大对象直接进入老年代：JVM中有个参数配置-XX:PretenureSizeThreshold，令大于这个设置值的对象直接进入老年代，目的是为了避免在Eden和Survivor区之间发生大

量的内存复制。

长期存活的对象进入老年代：JVM给每个对象定义一个对象年龄计数器，如果对象在Eden出生并经过第一次Minor

GC后仍然存活，并且能被Survivor容纳，将被移入Survivor并且年龄设定为1。没熬过一次Minor

GC，年龄就加1，当他的年龄到一定程度（默认为15岁，可以通过XX:MaxTenuringThreshold来设定），就会移入老年代。但是JVM并不是永远要求年龄必须达到最大年

龄才会晋升老年代，如果Survivor 空间中相同年龄（如年龄为x）所有对象大小的总和大于Survivor的一半，年龄大于等于x的所有对象直接进入老年代，无需等到最大年龄要求。

--------------------------------------我是分割线20200512--------------------------------------------------------