黑马-JVM

学习路线

内存结构

1、程序计数器（线程私有）

1.1定义

作用：记住下一条jvm指令的执行地址

特点

• 线程私有的
• 唯一不会存在内存溢出的区域

1.2作用

Java源代码->二进制字节码（jvm指令）->【解释器解释】机器码->CPU执行

2、虚拟机栈（线程私有）

2.1定义

栈：线程运行时需要的内存空间
栈帧：每个方法运行时需要的内存，栈由多个栈帧组成

每个线程只能有一个活动的栈帧，对应着当前正在执行的那个方法

栈的演示

public class test {

    public static void main(String[] args) {
        m1();
    }

    public static void m1(){
        m2(1,2);
    }
    public static int m2(int a,int b){
        int c = a + b;
        return c;
    }
}

问题辨析

1、垃圾回收是否涉及栈内存？
不需要！栈帧出栈的时候就已经释放掉了

2、栈内存分配越大越好吗？
不是！栈内存太大反而影响到线程数目，采用系统默认的大小即可

3、方法内的局部变量是否线程安全？
如果方法内部局部变量没有逃离方法的作用范围，它是线程安全的
如果是局部变量引用了对象，并逃离方法的作用范围，需要考虑线程安全

2.2栈内存溢出（StackOverFlowError）

什么情况下会发生栈内存溢出

• 栈帧过多（递归调用）
• 栈帧过大

设置栈内存大小

-Xss256k

2.3线程运行诊断

案例1：CPU占用过多

• 用top定位哪个进程对CPU的占用高

  top
  

• 用ps命令进一步定位是哪个线程引起的CPU占用过高（显示的线程是10进制）

  ps -H -eo pid,tid,%cpu | grep 进程id
  

• 用jstack工具将进程中的所有线程列出来（显示的线程id是16进制，因此查找问题的时候需要先将上一步查到的线程id换算成16进制），可以根据线程id找到有问题的线程，进一步定位到有问题的代码行数

  jstack 进程id
  

案例2：程序运行很长时间没有结果

jstack 进程id

3、本地方法栈（线程私有）

Java虚拟机调用本地方法（Native Method）时提供的内存空间

4、堆（线程共享）

4.1定义

Heap堆：通过new关键字创建的对象都会使用堆内存

特点

• 它是线程共享的，堆中对象都需要考虑线程安全的问题
• 有垃圾回收机制

4.2堆内存溢出（java.lang.OutOfMemoryEeror：Java heap space）

4.3 堆内存诊断

1、jps工具

查看当前系统中有哪些Java进程

2、jmap工具

查看堆内存占用情况（只能查看某一时刻）

jmap -heap 进程id

3、jconsole工具

图形界面的，多功能的检测工具，可以连续监测

案例

垃圾回收之后，内存占用依然很高

解决方法：使用jvisualvm可视化工具dump下堆内存快照进行分析

5、方法区（线程共享）

5.1定义

存储了跟类的结构相关的一些信息，包括类的成员变量、方法数据、成员方法和构造器方法的代码等。

5.2组成

重要！：

1、方法区在虚拟机启动时被创建，逻辑上是堆的组成部分
2、方法区是规范，永久代（jdk1.6，占用的是堆内存）和元空间（jdk1.8，占用的是系统的内存）只是实现。
3、注意看元空间里面的包含：类、类加载器、常量池
4、StringTable1.6是放在方法区，1.8则放到了堆空间

5.3方法区内存溢出（java.lang.OutOfMemoryEeror：Metaspace）

• jdk1.8以前会导致永久代内存溢出：java.lang.OutOfMemoryEeror：PermGen space
  需要先设置元空间内存大小，方便演示：-XX:MaxMetaspaceSize=8m

• jdk1.8之后会导致元空间内存溢出：java.lang.OutOfMemoryEeror：Metaspace

5.4运行时常量池

一文搞懂各种常量池

运行时常量池：常量池是*.class文件中的，当该类被加载，他的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实的地址。

public class Test2 {
    //StringTable是一个hashtable结构，不能扩容
    public static void main(String[] args) throws InterruptedException {
        // 常量池中的信息，都会被加载到运行时常量池中，这时a b ab都是常量池中的符号，还没有变为Java字符串对象
        String s1 = "a";// 只有执行到这一段代码时，a才会在StringTable中创建
        String s2 = "b";
        String s3 = "ab";

        String s4 = s1 + s2;// new StringBuilder().append(s1).append(s2).toString();  StringBuilder().toString()-->new String("ab");

        String s5 = "a" + "b";// 创建一个字符串String ab，先去常量池中查找，已经有了，就不创建了。底层为编译期的优化，已经有一个了就不另外创建了

        // s3是在常量池中；s4是一个对象，存放在堆中 答案就是false
        System.out.println(s3 == s4);
        // 他俩其实就是同一个
        System.out.println(s3 == s5);

        // 总结：所有的字符串的对象都是懒惰的，只有在用到时才会加载到StringTable中，加载的时候会先查找，没有才会放进去，有了就直接使用
    }
}

5.5StringTable特性

1、常量池中的字符串仅仅是符号，第一次用到时才变为对象
2、利用串池的机制，来避免重复创建字符串
3、字符串变量的拼接原理时StringBuilder
4、字符串常量拼接的原理是编译期优化
5、可以使用intern方法，主动将串池中还没有的字符串对象放入串池

public class Test3 {
    public static void main(String[] args) {
        // 此时的"a","b"都在常量池中：["a","b"]
        String s = new String("a") + new String("b");// 相当于new String("ab")，存放于堆中

        // 将这个字符创对象尝试放入串池，如果有则不放入，如果没有则放入串池，会把串池中的对象返回
        String s2 = s.intern();

        System.out.println(s2 == "ab");
    }
}

5.6StringTable位置（堆中）

jdk1.6在永久代中，不易被回收
jdk1.8之后在堆中，majorGC就可以回收掉，节约空间

5.7StringTable垃圾回收

StringTable中存在垃圾回收

5.8StringTable性能调优

StringTable底层是一个HashTable，因此调优就是调整HashTable桶的个数：
-XX:StringTableSize=10000
总结：当项目中字符串很多时，可以考虑调整StringTable，增加桶的个数，减少Hash碰撞

6、直接内存（系统内存）

直接内存
1、常见于NIO操作时，用于数据缓冲区
2、分配成本较高，但读写性能高
3、不受JVM内存回收管理

操作系统专门划出来一块内存，供Java直接使用，当然，操作系统也可以使用。

public class Demo4 {
    
    static int _100Mb = 1024 * 1024 * 100;
    
    public static void main(String[] args) {
        ByteBuffer allocate = ByteBuffer.allocate(_100Mb);
    }
}

7、垃圾回收

7.1如何判断对象可以回收

1、引用计数法

引用计数法的弊端：循环引用

2、可达性分析算法

• Java虚拟机中的垃圾回收器采用可达性分析来探索所有存活的对象
• 扫描堆中的对象，看是否能够沿着GC Root对象为起点的引用链找到该对象，找不到，表示可以回收
• 哪些对象可以作为GC Root？
  • System Class：系统核心类，如Object、HashMap、String
  • Native Stack：本地方法
  • Thread：活动线程和使用的对象
  • Busy Monitor：被加锁的对象

首先确定一系列根对象，何为根对象？即不可能被回收的对象

3、四种引用

• 强引用
  描述：直接和GC Root相连的对象，如上图的A1对象，
  回收时机：即使垃圾回收完内存不够也不会被回收掉

• 软引用
  描述：不直接和GC Root相连
  回收时机：垃圾回收结束内存还是不够时，会回收掉软引用
  应用：当读取一些大文件时，可以将读取的文件设为软引用，重读读取时可以避免内存溢出

  public class Test4 {
  
  private static final int _4MB = 4 * 1024 * 1024;
  
  public static void main(String[] args) {
      soft();
  }
  
  public static void soft(){
      ArrayList<SoftReference<byte[]>> softReferences = new ArrayList<>();
  
      ReferenceQueue<byte[]> queue = new ReferenceQueue<>();
  
      for (int i = 0; i < 5; i++) {
          // 关联引用队列，当软引用引用的byte数组被回收时，软应用自己就会加入引用队列中去
          SoftReference<byte[]> softReference = new SoftReference<>(new byte[_4MB],queue);
          System.out.println(softReference.get());
  
          softReferences.add(softReference);
          System.out.println(softReferences.size());
      }
  
      System.out.println("循环结束");
  
      // 清除无用的软引用本身
      Reference<? extends byte[]> poll = queue.poll();
      if (poll != null){
          softReferences.remove(poll);
          poll = queue.poll();
      }
  
      System.out.println("==============================");
      
      for (SoftReference<byte[]> softReference : softReferences) {
          System.out.println(softReference.get());
      }
  }
  

}
```

• 弱引用
  描述：不直接和GC Root相连
  回收时机：只要发生垃圾回收，就回收掉弱引用
• 虚引用（必须配合引用队列使用，主要配合ByteBuffer使用）
  描述：当虚引用创建的时候，必须关联一个引用队列
  回收时机：虚引用的对象被垃圾回收时，虚引用对象自己就会进入引用队列，从而间接地调用一个线程调用虚引用的方法，然后调用Unsafe.freeMemory区释放直接内存。
  描述：当虚引用创建的时候，必须关联一个引用队列
• 终结器应用（必须配合引用队列使用）

7.2垃圾回收算法

1、标记清除

优点：速度快
缺点：容易产生内存碎片，导致内存不连续

2、标记整理

标记过程和“标记-清除算法”一样，但后续步骤是让所有存活的对象都向内存空间一端移动，然后直接清理掉边界以外的内存
优点：不会产生内存碎片
缺点：由于整理要移动对象，导致效率较低

3、复制

将可用内存按容量划分为大小相等的两块，每次只使用其中的一块，当这一块用完了，就将还存活着的对象复制到另一块上面，然后再把已使用过的内存空间一次性清理掉。
优点：不会产生内存碎片
缺点：要占用双倍的内存空间

7.3分代垃圾回收

1、垃圾回收过程

新创建的对象，默认会存放在伊甸园区，当伊甸园区满了之后，就会触发一次Minor GC，Minor GC采用复制算法，将存活的对象放入幸存区TO中，同时给存活的对象的寿命+1（此时伊甸园区就回收掉释放出空间），Minor GC完成之后，会交换幸存区FROM和幸存区TO。

当伊甸园区再次满了之后，开始第二次垃圾回收，同样会将幸存的对象放入幸存区FROM，同时会对幸存区TO中进行一次垃圾回收，没有被回收掉的对象同样会被放进幸存区FROM，而且寿命+1，最后，交换幸存区FROM和幸存区TO

当幸存区FROM中的对象的寿命达到15时，会被放倒老年代中。老年代满了之后，会触发一次Minor GC，如果回收之后空间仍然不足，那么触发Full GC

重要：Minor GC算法：复制，Full GC算法：标记清除/标记清理

2、相关VM参数

7.4垃圾回收器

JDK8默认的垃圾收集器为： Parallel Scavenge（新生代，标记复制算法）+ Serial Old（老年代，标记整理算法）

1、串行（Serial【串行】）

特点：单线程、堆内存较小，CPU核心数比较少

开启串行垃圾回收器：
-XX:+UseSerialGC = Serial + SerialOld
说明：Serial工作在新生代，采用复制算法，SerialOld工作在老年代，采用标记整理算法

相关的垃圾收集器：
1、ParNew，实质上是Serial收集器的多线程并行版本，常用搭配：ParNew（新生代）+CMS（老年代）
2、Serial Old：Serial收集器的老年代版本，采用标记整理算法，常用搭配：Parallel Scavenge（新生代）+ Serial Old（老年代）

2、吞吐量优先（Parallel【并行】）

特点：多线程、堆内存较大，多核CPU、让单位时间内，STW的时间最短，多个垃圾回收线程同时运行，但用户线程会暂停

开启并行的垃圾回收器：
-XX:+UseParallelGC（新生代、复制算法） ~ -XX:+UseParallelOldGC（老年代、标记整理算法）

相关的垃圾收集器：
1、Parallel Scavenge：新生代收集器，基于标记复制算法，常用搭配：Parallel Scavenge（新生代）+ Serial Old（老年代）
2、Parallel Old：是Parallel Scavenge的老年代版本，基于标记整理算法

二者搭配就是JDK8默认的垃圾收集器

3、响应时间优先（CMS【并发】）

特点：多线程、堆内存较大，多核CPU、垃圾回收时尽可能让单次STW的时间最短、工作的同时用户线程也能并发运行

开启：
-XX:+UseConcMarkSweepGc（老年代） ~ -XX:+UseParNewGC（新生代） ~ SerialOld（并发失败时的补救措施）
-XX:+CMSScavengeBeforeRemark：由于重新标记比较耗时，因此在重新标记前就清理一下新生代，降低标记时长

常用搭配：ParNew（新生代）+CMS（老年代）

面试必答：
1、基于标记清除算法实现
2、工作流程是：初始标记、并发标记、重新标记、并发清除
3、缺点：
1、会产生内存碎片（因为是基于标记清除算法，解决：增大Full GC的频率）
2、重新标记阶段比较耗时（解决：在执行重新标记之前先做一次Young GC）
3、Promotion Failed问题（导致的原因是在进行Minor GC的时候，老年代空间不足，无法放下大对象，解决：对内存占用率达到60%的时候就开始GC）

重点：初始标记和重新标记存在STW

重新理解CMS

4、G1

特点：
1、同时注重吞吐量和低延迟，默认暂停时间是200ms
2、超大堆内存，会将堆划分为多个大小相等的Region
3、整体上是标记+整理算法，两个区域之间是复制算法

相关参数：
-XX:UseG1GC
-XX:G1HeapRegionSize=size
-XXMaxGCPauseMillis=time

面试必答：
1、特点：同时追求高吞吐量和低延时、能够预测GC停顿时间。
2、内存布局：把堆内存划分为多个大小相等的独立区域即Region。每一个Region都可以根据需要去扮演Eden区，Survivor区，Old区，Humongous区。(注：Humongous区是一类特殊区域专门存放大对象)。
3、回收过程：在回收时以Region作为最小的回收单位，G1会预测出每个Region的回收时间，回收后得到的内存大小以此计算出的该Region回收的"价值"，根据用户设置的期望GC停顿时间，每次回收优先处理回收价值最大的Region，这也是G1(Garabage First)名字的由来原因。
4、好处：一次回收不用针对全部内存，只需要先回收垃圾最多的region，提高了垃圾收集的效率、变相实现了只有新生代才有的复制算法，极大减少了空间碎片的产生(后续会提到)
5、缺点：跨region引用（解决：引入了RSet(Remembered Set)，用于记录其他Region指向该Region的引用）

重新理解G1

5、Full GC概念辨析

• SerialGC
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足发生的垃圾收集 - full gc
• ParallelGC
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足发生的垃圾收集 - full gc
• CMS
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足发生的垃圾收集
    • 在并发收集的阶段，回收速度高于垃圾产生的速度：并发标记
    • 在并发收集的阶段，回收速度低于垃圾产生的速度：full gc
• G1
  • 新生代内存不足发生的垃圾收集 - minor gc
  • 老年代内存不足（老年代占用堆空间大于45%）发生的垃圾收集
    • 在并发收集的阶段，回收速度高于垃圾产生的速度：并发标记
    • 在并发收集的阶段，回收速度低于垃圾产生的速度：full gc

6、三色标记

三色标记详解

7、G1回收器的优化

1、字符串去重
创建两个相同的字符串：

String s1 = new String("abc");// char[]{'a','b','c'}
String s2 = new String("abc");// char[]{'a','b','c'}

将所有新分配的字符串放入一个队列，当新生代回收时，G1并发检查时否有字符串的重复，如果他们值一样，让他们引用同一个char[]

2、并发标记类卸载
所有对象都经过并发标记后，就能知道哪些类不再被使用，当一个类加载器的所有类都不再使用时，则卸载它所加载的所有类
3、回收巨型对象
一个对象大于region的一半时，称之为巨型对象，G1不会对巨型对象进行拷贝，回收时被有限考虑。
4、并发标记起始时间

7.5垃圾回收调优

8、类加载与字节码技术

8.1类文件结构

8.2字节码指令

8.3语法糖

8.4类加载阶段

类加载的阶段：加载-链接-初始化

1、加载

• 将类的字节码载入方法区中，内部采用C++的instanceKlass描述Java类，他的重要field有：
  • _java_mirror即Java的类镜像
  • _super即父类
  • _fields即成员变量
  • _methods即方法
  • _constansts即常量池
• 如果这个类还有父类没有加载，就先加载父类
• 加载和链接可能是交替运行的
  
  用关键字new创建一个Person的实例对象，实例对象都有自己的对象头（16字节），其中8个字节对应着class对象地址，如果想访问实例对象的属性，首先会通过class地址找到java mirror地址（上图中绿色部分），再通过instanceKlass地址找到元空间中instanceKlass，就可以调用这个类的属性信息了。

2、链接

链接阶段又分为三个小的阶段

• 验证：验证类是否符合JVM规范，安全性检查
• 准备：为static变量分配空间，设置默认值
  • static分配空间和赋值是两个步骤，分配空间在准备阶段完成，复制在初始化阶段（下一步）完成
  • 如果static变量时final的基本类型，那么编译阶段值就确定了，复制在准备阶段完成
  • 如果static变量的是是final的，但是属于引用类型，那么复制也会在初始化阶段（下一步）完成
• 解析：将常量池中的符号引用解析为直接引用

3、初始化

初始化即调用类的构造方法，虚拟机保证这个类的构造方法的线程安全

概括得说，类初始化是【懒惰的】，以下几种情况会导致类的初始化：

• main方法所在类，总是被首先初始化
• 首次访问这个类的静态变量或静态方法时
• 子类的初始化，如果父类还没初始化，会引发父类的初始化
• 子类访问父类的静态变量，只会触发父类的初始化
• Class.forName
• new关键字会导致初始化

不会导致类初始化的情况：

• 访问类的static final静态常量（基本类型和字符串）不会触发初始化
• 类对象.class不会触发初始化
• Class.forName的参数2为false时（人为指定）

8.5、类加载器

1、以JDK8为例：

2、双亲委派模式

双亲委派模型的工作过程是：如果一个类加载器收到了类加载的请求，它首先不会自己去尝试加载这个类，而是把这个请求委派给父类加载器完成，每一个层次的类加载器都是如此，因此所有的加载请求最终都应该传送到最顶层的启动类加载器中，只有当父类加载器反馈自己无法完成这个加载请求时，子类加载器才会尝试自己去完成加载。