JVM学习记录

admin管理员组

文章数量:1547926

JVM

JVM是什么：

JVM是Java Virtual Machine的缩写。它是一种基于计算设备的规范，是一台虚拟机，即虚构的计算机。
通过JVM，Java实现了平台无关性，Java语言在不同平台运行时不需要重新编译，只需要在该平台上部署JVM就可以了。因而能实现一次编译多处运行。

图中灰色的Java栈、本地方法区、程序计数器是线程私有的，基本不存在垃圾回收。
亮色的方法区和堆是线程共享的；且存在垃圾回收，大部分收堆里的垃圾。

类加载器

1. 类型
   虚拟机自带的加载器：
   爷爷：启动类加载器bootstrap C++ 加载jdk自带的类，比如object
   父亲：扩展类加载器extension Java 加载javax包中的类
   儿子：应用程序类加载器appclassloader 加载当前应用的classpath的所有类
   用户自定义加载器：
   Java.lang.ClassLoader的子类，用户可以定制类的加载方式。
2. 双亲委派
   当一个类收到了类加载请求，它首先不会去自己加载这个类，而是把这个请求委派给父类去完成，每一个层次类都是如此，如果父类加载器无法加载，子类才会去尝试加载。
   双亲委派的好处是，不管是哪个加载器去加载Object，最终都会委托给顶层的启动类加载器进行加载，这样就保证了使用不同的类加载器最终得到的都是同一个Object对象
3. 沙箱安全机制
   沙箱安全机制是由基于双亲委派机制上，采取的一种JVM的自我保护机制,假设你要写一个java.lang.String 的类,由于双亲委派机制的原理,此请求会先交给启动类加载器(Bootstrap)试图进行加载,但是Bootstrap在加载类时首先通过包和类名查找rt.jar中有没有该类,有则优先加载rt.jar包中的类,因此就保证了java的运行机制不会被破坏.
4. 类加载流程
   

   /**
    * JVM自带的加载器
    */
   public class MyObject {
       public static void main(String[] args) {
           Object object = new Object();
           // NullPointerException ，Object是自带的，没有父亲
   //        System.out.println(object.getClass().getClassLoader().getParent().getParent());
   //        System.out.println(object.getClass().getClassLoader().getParent());
           //null 启动类（根）加载器 Object使用启动类（bootstrap）加载器，它是用C++语言写的，通过Java代码无法得到
           System.out.println(object.getClass().getClassLoader());
   
           MyObject myObject = new MyObject();
           //null
           System.out.println(myObject.getClass().getClassLoader().getParent().getParent());
           //ExtClassLoader 扩展类加载器
           System.out.println(myObject.getClass().getClassLoader().getParent());
           //AppClassLoader 应用程序类加载器
           System.out.println(myObject.getClass().getClassLoader());
       }
   }
   

执行引擎

execution engine执行引擎负责解释命令，提交操作执行系统。

Native

native是一个关键字
有声明，无实现，告诉虚拟机去调用C语言
它的存在是为了融合C和C++程序

1. 本地方法接口：
   内存中单独开辟的一块区域处理标记为native的代码，具体做法是本地方栈中登记native方法，在执行引擎执行时加载本地方法库。
   该方法使用的很少了，除非是与硬件有关的应用
2. 本地方法栈：
   具体做法是本地方栈中登记native方法，在执行引擎执行时加载本地方法库。

PC寄存器（程序计数器）

它在CPU里面
记录了方法之间的调用和执行情况。
PC寄存器用来存储指向下一条指令的地址，也即将要执行的指令代码。它是当前线程所执行的字节码的信号指示器。由执行引擎读取下一条指令，并执行该指令。

方法区method area

方法区和堆一样，是线程共享的内存区域，它用于存储虚拟机加载的：类信息+普通常量+静态常量+编译器编译后的代码。虽然JVM规范将方法区描述为堆得一个逻辑部分，但，它还称非堆（Non-Heap），目的就是要和堆分来。
存储每个类的结构信息，就是类的模板。例如：运行时常量池，字段和方法数据，构造函数和普通方法的字节码内容。方法区是规范，在不同的虚拟机中实现是不同的，最典型的就是永久代（1.7及之前）和元空间（1.8）。
注意：实例变量存在堆内存中，和方法区无关。

	public class Demo {
		//以下都是实例变量（成员变量、对象变量）
		private String nameString;
		public int age;
		protected int priority;
		//实例方法
		public String getNameString(){
		}
	}

栈stack

1. 栈管运行，堆管存储

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

3. 栈存储什么
   栈帧中主要保存3类数据：
   （1）本地变量local variables：输入参数和输出参数以及方法内的变量

   public int add (int a, int b) {//输入参数
           int result = 0;//方法内的变量
           result = a + b;
           return result;//输出参数
       }
   

（2）栈操作operand stack：记录出栈和入栈的操作
（3）栈帧数据：包括类文件、方法等等
4. 运行原理

栈 堆 方法区的关系

Hotspot：它是Sun JDK和OpenJDK中所带的虚拟机，也是目前使用范围最广的Java虚拟机。
什么是类元数据，说白了就是去方法区中得到类的模板
Persion p1 = new Persion();
p1是reference 引用对象在栈中，new Persion()这个实例对象在堆里面，而创建类的模板在方法区中
内存溢出：

public class StackDemo {
    public static void m1() {
	    //System.out.println("m1====");
        //Exception in thread "main" java.lang.StackOverflowError
        m1();
    }

    public static void main(String[] args) {
        System.out.println("main====");
        m1();
        System.out.println("after m1 ====");
    }

堆heap

• 介绍
  
  逻辑上分为三部分：新生代+老年代+元空间（JDK1.8之后）
  物理上分为两部分：新生代+老年代
• 新生区：
  
• 流程
  
• GC的过程：复制->清空->互换
  
  1：eden、SurvivorFrom 复制到 SurvivorTo，年龄+1
  首先，当Eden区满的时候会触发第一次GC,把还活着的对象拷贝到SurvivorFrom区，当Eden区再次触发GC的时候会扫描Eden区和From区域,对这两个区域进行垃圾回收，经过这次回收后还存活的对象,则直接复制到To区域（如果有对象的年龄已经达到了老年的标准，则赋值到老年代区），同时把这些对象的年龄+1

2：清空 eden、SurvivorFrom
然后，清空Eden和SurvivorFrom中的对象，也即复制之后有交换，谁空谁是to

3：SurvivorTo和 SurvivorFrom 互换
最后，SurvivorTo和SurvivorFrom互换，原SurvivorTo成为下一次GC时的SurvivorFrom区。部分对象会在From和To区域中复制来复制去,如此交换15次(由JVM参数MaxTenuringThreshold决定,这个参数默认是15),最终如果还是存活,就存入到老年代

注意：
对象的生命周期

Java对象在JVM中的生命周期
当你通过new语句创建一个java对象时，JVM就会为这个对象分配一块内存空间，只要这个对象被引用变量引用了，那么这个对象就会一直驻留在内存中，否则，它就会结束生命周期，JVM会在合适的时候回收它所占用的内存。

• OOM堆内存溢出演示
  当老年代进行FullGC后，依然无法进行对象的保存时，会产生OutOfMemoryError，注意，是错误，不是异常。
  先修改VM参数： -Xms10m -Xmx10m -XX:+PrintGCDetails

  public static void main(String[] args) {
          String str = "11";
          while (true){
              str += str + new Random().nextInt(88888888) + new Random().nextInt(999999999);
          }
      }
  

  运行：
• 元空间（永久代）
  对于Hotspot虚拟机，很多开发者将方法区成为“永久代”，但严格意义上说，二者本质不同，或者说使用永久代来实现方法区而已，永久代是方法区的一个实现。
  永久代存储的是jdk自身带的class、interface元数据，它存储jre运行环境必须的类信息，备装载进此区域是不会被垃圾回收的，关闭JVM才会释放此区域所占用的内存。
  元空间的本质和永久代类似，都是对JVM规范中方法区的实现。不过元空间与永久代之间最大的区别在于：元空间并不在虚拟机中，而是使用本地内存。因此，默认情况下，元空间的大小仅受本地内存限制，但可以通过以下参数来指定元空间的大小：
  　　-XX:MetaspaceSize，初始空间大小，达到该值就会触发垃圾收集进行类型卸载，同时GC会对该值进行调整：如果释放了大量的空间，就适当降低该值；如果释放了很少的空间，那么在不超过MaxMetaspaceSize时，适当提高该值。
  　　-XX:MaxMetaspaceSize，最大空间，默认是没有限制的。
  　　除了上面两个指定大小的选项以外，还有两个与 GC 相关的属性：
  　　-XX:MinMetaspaceFreeRatio，在GC之后，最小的Metaspace剩余空间容量的百分比，减少为分配空间所导致的垃圾收集
  　　-XX:MaxMetaspaceFreeRatio，在GC之后，最大的Metaspace剩余空间容量的百分比，减少为释放空间所导致的垃圾收集
• 堆内存调优，参数调整
  
  
  
  证明堆的组成：
  首先修改参数：-Xms1024m -Xmx1024m -XX:+PrintGCDetails

  public static void main(String[] args) {
          //System.out.println(Runtime.getRuntime().availableProcessors());//查看电脑几核
          long maxMemory = Runtime.getRuntime().maxMemory();
          long totalMemory = Runtime.getRuntime().totalMemory();
          System.out.println("-Xmx:maxMemory:   "+ maxMemory +"(字节)、"+(maxMemory / (double)1024/1024+"MB"));
          System.out.println("-Xms:totalMemory:   "+ totalMemory +"(字节)、"+(totalMemory / (double)1024/1024+"MB"));
      }
  

打印细节：证明堆物理上是由新生代和老年代组成的
305664/1024+699392/1024=981.5
输出：

注意：
元空间并不在虚拟机中，而是在本机物理内存

垃圾GC回收日志信息

GC：

[GC (Allocation Failure) 
[PSYoungGen: 2044K->504K(2560K)] 2044K->737K(9728K), 0.0019013 secs] 
[Times: user=0.00 sys=0.00, real=0.00 secs] 

Full GC

[Full GC (Allocation Failure) 
[PSYoungGen: 0K->0K(1536K)] 
[ParOldGen: 4128K->4109K(7168K)] 4128K->4109K(8704K), 
[Metaspace: 3229K->3229K(1056768K)], 0.0110255 secs] 
[Times: user=0.05 sys=0.00, real=0.01 secs]

规律：[名称：GC前内存占用->GC后内存占用（该区内存总大小）

GC垃圾回收

垃圾回收作用区域：方法区+堆

1. GC是什么：分代收集算法（Generational Collection）
   次数上频繁收集young区
   较少收集old区
   基本不动元空间
   
   JVM在进行GC时，并非每次都对上面三个内存区域一起回收的，大部分时候回收的都是指新生代。
   因此GC按照回收的区域又分了两种类型，一种是普通GC（minor GC）又叫，一种是全局GC（major GC or Full GC）
   Minor GC和Full GC的区别：
   　　普通GC（minor GC）：只针对新生代区域的GC,指发生在新生代的垃圾收集动作，因为大多数Java对象存活率都不高，所以Minor GC非常频繁，一般回收速度也比较快。
   　　全局GC（major GC or Full GC）：指发生在老年代的垃圾收集动作，出现了Major GC，经常会伴随至少一次的Minor GC（但并不是绝对的）。Major GC的速度一般要比Minor GC慢上10倍以上

GC四大算法

（1）引用计数法

如果两个对象互相应用，但两个对象都无其他引用，但对象的引用计数不是0，不会被垃圾收集。

（2）复制算法（copying）

年轻代中使用的是Minor GC，这种GC算法采用的是复制算法(Copying)

复制算法的基本思想就是将内存分为两块，每次只用其中一块，当这一块内存用完，就将还活着的对象复制到另外一块上面。复制算法不会产生内存碎片。
在GC开始的时候，对象只会存在于Eden区和名为“From”的Survivor区，Survivor区“To”是空的。紧接着进行GC，Eden区中所有存活的对象都会被复制到“To”，而在“From”区中，仍存活的对象会根据他们的年龄值来决定去向。年龄达到一定值(年龄阈值，可以通过-XX:MaxTenuringThreshold来设置)的对象会被移动到年老代中，没有达到阈值的对象会被复制到“To”区域。经过这次GC后，Eden区和From区已经被清空。这个时候，“From”和“To”会交换他们的角色，也就是新的“To”就是上次GC前的“From”，新的“From”就是上次GC前的“To”。不管怎样，都会保证名为To的Survivor区域是空的。Minor GC会一直重复这样的过程，直到“To”区被填满，“To”区被填满之后，会将所有对象移动到年老代中。

因为Eden区对象一般存活率较低，一般的，使用两块10%的内存作为空闲和活动区间，而另外80%的内存，则是用来给新建对象分配内存的。一旦发生GC，将10%的from活动区间与另外80%中存活的eden对象转移到10%的to空闲区间，接下来，将之前90%的内存全部释放，以此类推。

Minor GC会把Eden中的所有活的对象都移到Survivor区域中，如果Survivor区中放不下，那么剩下的活的对象就被移到Old generation中，也即一旦收集后，Eden是就变成空的了。
当对象在 Eden ( 包括一个 Survivor 区域，这里假设是 from 区域 ) 出生后，在经过一次 Minor GC 后，如果对象还存活，并且能够被另外一块 Survivor 区域所容纳( 上面已经假设为 from 区域，这里应为 to 区域，即 to 区域有足够的内存空间来存储 Eden 和 from 区域中存活的对象 )，则使用复制算法将这些仍然还存活的对象复制到另外一块 Survivor 区域 ( 即 to 区域 ) 中，然后清理所使用过的 Eden 以及 Survivor 区域 ( 即 from 区域 )，并且将这些对象的年龄设置为1，以后对象在 Survivor 区每熬过一次 Minor GC，就将对象的年龄 + 1，当对象的年龄达到某个值时 ( 默认是 15 岁，通过-XX:MaxTenuringThreshold 来设定参数)，这些对象就会成为老年代。

-XX:MaxTenuringThreshold — 设置对象在新生代中存活的次数
复制算法的缺点：
1、它浪费了一半的内存，这太要命了。
2、如果对象的存活率很高，我们可以极端一点，假设是100%存活，那么我们需要将所有对象都复制一遍，并将所有引用地址重置一遍。复制这一工作所花费的时间，在对象存活率达到一定程度时，将会变的不可忽视。 所以从以上描述不难看出，复制算法要想使用，最起码对象的存活率要非常低才行，而且最重要的是，我们必须要克服50%内存的浪费。

（3）标记清除Mark-Sweep

老年代一般是由标记清除或者是标记清除与标记整理的混合实现

√没有复制，不需要额外空间
×两次扫描，耗时严重
×会产生内存碎片

用通俗的话解释一下标记清除算法，就是当程序运行期间，若可以使用的内存被耗尽的时候，GC线程就会被触发并将程序暂停，随后将要回收的对象标记一遍，最终统一回收这些对象，完成标记清理工作接下来便让应用程序恢复运行。

主要进行两项工作，第一项则是标记，第二项则是清除。
标记：从引用根节点开始标记遍历所有的GC Roots， 先标记出要回收的对象。
清除：遍历整个堆，把标记的对象清除。
缺点：此算法需要暂停整个应用，会产生内存碎片
1、首先，它的缺点就是效率比较低（递归与全堆对象遍历），而且在进行GC的时候，需要停止应用程序，这会导致用户体验非常差劲
2、其次，主要的缺点则是这种方式清理出来的空闲内存是不连续的，这点不难理解，我们的死亡对象都是随即的出现在内存的各个角落的，现在把它们清除之后，内存的布局自然会乱七八糟。而为了应付这一点，JVM就不得不维持一个内存的空闲列表，这又是一种开销。而且在分配数组对象的时候，寻找连续的内存空间会不太好找。

（4）标记压缩Mark-Compact

老年代一般是由标记清除或者是标记清除与标记整理的混合实现

缺点：标记/整理算法唯一的缺点就是效率也不高，不仅要标记所有存活对象，还要整理所有存活对象的引用地址。
从效率上来说，标记/整理算法要低于复制算法。

标记清除压缩Mark-Sweep-Compact:结合使用

GC垃圾回收总结

内存效率：复制算法>标记清除算法>标记整理算法（时间复杂度）
内存整齐度：复制算法=标记整理算法>标记清除算法
内存利用率：标记整理算法=标记清除算法>复制算法

没有最好的算法，只有最合适的，统一叫做分代收集算法

G1(Garbage-First)介绍：
在G1中，堆被划分成 许多个连续的区域(region)。每个区域大小相等，在1M~32M之间。JVM最多支持2000个区域，可推算G1能支持的最大内存为2000*32M=62.5G。区域(region)的大小在JVM初始化的时候决定，也可以用-XX:G1HeapReginSize设置。
在G1中没有物理上的Yong(Eden/Survivor)/Old Generation，它们是逻辑的，使用一些非连续的区域(Region)组成的。

年轻代(Young Gen)

年轻代特点是区域相对老年代较小，对像存活率低。

这种情况使用复制算法的回收整理，速度是最快的。复制算法的效率只和当前存活对像大小有关，因而很适用于年轻代的回收。而复制算法内存利用率不高的问题，通过hotspot中的两个survivor的设计得到缓解。

老年代(Tenure Gen)

老年代的特点是区域较大，对像存活率高。

这种情况，存在大量存活率高的对像，复制算法明显变得不合适。一般是由标记清除或者是标记清除与标记整理的混合实现。

Mark&Sweep&Compact G1

Mark阶段的开销与存活对像的数量成正比，这点上说来，对于老年代，标记清除或者标记整理有一些不符，但可以通过多核/线程利用，对并发、并行的形式提标记效率。

Sweep阶段的开销与所管理区域的大小形正相关，但Sweep“就地处决”的特点，回收的过程没有对像的移动。使其相对其它有对像移动步骤的回收算法，仍然是效率最好的。但是需要解决内存碎片问题。

Compact阶段的开销与存活对像的数据成开比，如上一条所描述，对于大量对像的移动是很大开销的，做为老年代的第一选择并不合适。

基于上面的考虑，老年代一般是由标记清除或者是标记清除与标记整理的混合实现。
以hotspot中的CMS回收器为例，CMS是基于Mark-Sweep实现的，对于对像的回收效率很高，而对于碎片问题，CMS采用基于Mark-Compact算法的Serial Old回收器做为补偿措施：当内存回收不佳（碎片导致的Concurrent Mode Failure时），将采用Serial Old执行Full GC以达到对老年代内存的整理。

面试题

1. JVM内存模型以及分区，需要详细到每个区放什么
   Java虚拟机规范中定义了Java内存模型（Java Memory Model，JMM），本身是一种抽象的概念 并不真实存在。用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作的：规定了一个线程如何何时可以看到由其他线程修改过后的共享变量的值，以及在必须时如何同步的访问共享变量。
   可见性，原子性，有序性。
   
   
2. 堆里面的分区：Eden，survival from to，老年代，各自的特点。
   Eden区位于Java堆的年轻代，是新对象分配内存的地方。如果Eden区内存用完了，则会进行一次Minor GC（young GC）。
   Survival区与Eden区相同都在Java堆的年轻代。Survival区有两块，一块称为from区，另一块为to区，这两个区是相对的，在发生一次Minor GC后，from区就会和to区互换。在发生Minor GC时，Eden区和Survivalfrom区会把一些仍然存活的对象复制进Survival to区，并清除内存。Survival to区会把一些存活得超过15岁的对象移至年老代。
   年老代里存放的都是存活时间较久的，大小较大的对象，因此年老代使用标记整理算法。当年老代容量满的时候，会触发一次Major GC（full GC），当fullGC后也没有空间后，就会爆出OOM(OutOfMemoryError)错误。
3. GC的三种收集方法：标记清除、标记整理、复制算法的原理与特点，分别用在什么地方
   标记清除：
   原理：分为两个阶段标记和清除，先对需要回收的对象进行标记，再统一回收。
   特点：效率较低，且产生大量不连续的碎片。
   发生区：老年区，比如CMS收集器就是采用该算法进行回收的
   标记整理：
   原理：分为两个阶段标记和整理，首先标记出所有需要回收的对象，让所有存活的对象都向一端移动，然后直接清理掉端边界以外的内存。
   特点：效率低，但是不会产生碎片
   发生区：老年代，parallel Old（针对parallel scanvange gc的） gc和Serial old收集器就是采用该算法进行回收的。
   复制算法：
   原理：当对象在 Eden 出生后，在经过一次 Minor GC 后，如果对象还存活，并且能够被另外一块 Survivor 区域所容纳，则使用复制算法将这些仍然还存活的对象复制到另外一块 Survivor 区域 中
   特点：高效，没有内存碎片，但是需要双倍空间。
   发生区：新生代，因为Eden区对象一般存活率较低。
4. Minor GC与Full GC分别在什么时候发生
   minor GC：Eden区域满了，或者新创建的对象大小 > Eden所剩空间
   Full GC
   a) 年老代（Tenured）被写满；
   b) 持久代（Perm）被写满；
   c) System.gc()被显示调用；
   d) 上一次GC之后Heap的各域分配策略动态变化；

本文标签： JVM