JVM学习

最新推荐文章于 2023-10-12 11:23:31 发布
最新推荐文章于 2023-10-12 11:23:31 发布
阅读量264 收藏
点赞数
分类专栏： JVM Java 文章标签： jvm java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53756694/article/details/113801495
版权
Java 同时被 2 个专栏收录
2 篇文章 1 订阅
订阅专栏
JVM
1 篇文章 0 订阅
订阅专栏

文章目录

本博客是根据解密JVM【黑马程序员出品】教学视频学习时，所做的笔记，目前笔记缺少类加载部分知识点！

一、什么是JVM？

定义

Java Virtual Machine，JAVA程序的运行环境（JAVA二进制字节码的运行环境）

好处

一次编写，到处运行
自动内存管理，垃圾回收机制
数组下标越界检查

比较

JVM JRE JDK的区别
在这里插入图片描述

二、内存结构

整体架构

在这里插入图片描述

1.程序计数器（Program Counter Register）

作用

用于保存JVM中下一条所要执行的指令的地址

特点

  1. 线程私有
    （1）CPU会为每个线程分配时间片，当当前线程的时间片使用完以后，CPU就会去执行另一个线程中的代码
    （2）程序计数器是每个线程所私有的，当另一个线程的时间片用完，又返回来执行当前线程的代码时，通过程序计数器可以知道应该执行哪一句指令
  2. 不会存在内存溢出

2.虚拟机栈（JVM Stacks）

类似于“桶”的先进后出的数据结构

定义

  • 每个线程运行需要的内存空间，称为虚拟机栈
  • 每个栈由多个栈帧组成，对应着每次调用方法时所占用的内存
  • 每个线程只能有一个活动栈帧，对应着当前正在执行的方法
    在这里插入图片描述

演示

代码

public class Main {
	public static void main(String[] args) {
		method1();
	}

	private static void method1() {
		method2(1, 2);
	}

	private static int method2(int a, int b) {
		int c = a + b;
		return c;
	}
}

此处可以观察到“栈”的先进先出！先执行的方法后出。在控制台中可以看到，主类中的方法在进入虚拟机栈的时候，符合栈的特点
在这里插入图片描述

问题辨析

  • 垃圾回收是否涉及栈内存？
    不需要。因为虚拟机栈中是由一个个栈帧组成的，在方法执行完毕后，对应的栈帧就会被弹出栈。所以无需通过垃圾回收机制去回收内存。
  • 栈内存的分配越大越好吗？
    不是。因为物理内存是一定的，栈内存越大，可以支持更多的递归调用，但是可执行的线程数就会越少。
  • 方法内的局部变量是否是线程安全的？
    如果方法内局部变量没有逃离方法的作用范围，则是线程安全的
    如果如果局部变量引用了对象，并逃离了方法的作用范围，则需要考虑线程安全问题

内存溢出

Java.lang.stackOverflowError 栈内存溢出

发生原因

  • 虚拟机栈中，栈帧过多（无限递归）
  • 每个栈帧所占用过大

线程运行诊断

CPU占用过高

  1. Linux环境下运行某些程序的时候，可能导致CPU的占用过高，这时需要定位占用CPU过高的线程
    （1）top命令，查看是哪个进程占用CPU过高
    （2）ps H -eo pid, tid（线程id）, %cpu | grep 刚才通过top查到的进程号 通过ps命令进一步查看是哪个线程占用CPU过高
    （3）jstack 进程id 通过查看进程中的线程的nid，刚才通过ps命令看到的tid来对比定位，注意jstack查找出的线程id是16进制的，需要转换

3.本地方法栈（Native Method Stacks）

定义

一些带有native关键字的方法就是需要JAVA去调用本地的C或者C++方法，因为JAVA有时候没法直接和操作系统底层交互，所以需要用到本地方法

共同点

小总结：(1)(2)(3)线程私有

4.堆（Heap）

定义

通过new关键字创建的对象都会被放在堆内存

特点

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

堆内存溢出

java.lang.OutofMemoryError ：java heap space. 堆内存溢出

堆内存诊断

jps ##工具 （查看当前系统中有哪些java进程）

jmap ##工具（查看堆内存的占用情况） 只能查看某一个时刻的情况

jconsole ## 工具 （图形界面 多功能检测工具 可以连续监测）

jvirsalvm ## 工具 （图形界面 多功能检测工具 可以连续监测）

5.方法区（Method Area）

结构

在这里插入图片描述

内存溢出

  • 1.8以前会导致永久代内存溢出
//永久代内存溢出
java.lang.OutOfMemoryError： PermGen space
//调节其大小的JVM参数命令
-XX:MaxPermSize=8m //设置为8M大小
  • 1.8以后会导致元空间内存溢出
//永久代内存溢出
java.lang.OutOfMemoryError： Metaspace
//调节其大小的JVM参数命令
-XX:MaxMetaspaceSize=8m //设置为8M大小

常量池

二进制字节码的组成：类的基本信息、常量池、类的方法定义（包含了虚拟机指令）

反编译工具查看类的信息

（1）首先编译代码 然后 cd 到生成.class的绝对路径
在这里插入图片描述
（2）然后在其控制台输入 javap -v XX.class
在这里插入图片描述

  • 然后就可以看见类的基本信息了
    基本信息
    在这里插入图片描述
    常量池
    在这里插入图片描述
    虚拟机中执行编译的方法（框内的是真正编译执行的内容，#号的内容需要在常量池中查找）
    在这里插入图片描述

运行时常量池

  • 常量池
    就是一张表（如上图中的constant pool），虚拟机指令根据这张常量表找到要执行的类名、方法名、参数类型、字面量信息
  • 运行时常量池
    常量池是.class文件中的，当该*类被加载以后，它的常量池信息就会放入运行时常量池，并把里面的符号地址变为真实地址

常量池与串池的关系

串池StringTable
  • 特征
    （1）常量池中的字符串仅是符号，只有在被用到时才会转化为对象
    （2）利用串池的机制，来避免重复创建字符串对象
    （3）字符串变量拼接的原理是StringBuilder
    （4）字符串常量拼接的原理是编译器优化
    （5）可以使用intern()方法，主动将串池中还没有的字符串对象放入串池中

注意：无论是串池还是堆里面的字符串，都是对象

用来放字符串对象且里面的元素不重复

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a"; 
		String b = "b";
		String ab = "ab";
	}
}

常量池中的信息，都会被加载到运行时常量池中，但这是a b ab 仅是常量池中的符号，还没有成为java字符串

0: ldc           #2                  // String a
2: astore_1
3: ldc           #3                  // String b
5: astore_2
6: ldc           #4                  // String ab
8: astore_3
9: return

当执行到 ldc #2 时，会把符号 a 变为 “a” 字符串对象，并放入串池中（hashtable结构 不可扩容）

当执行到 ldc #3 时，会把符号 b 变为 “b” 字符串对象，并放入串池中

当执行到 ldc #4 时，会把符号 ab 变为 “ab” 字符串对象，并放入串池中

最终StringTable [“a”, “b”, “ab”]

注意：字符串对象的创建都是懒惰的，只有当运行到那一行字符串且在串池中不存在的时候（如 ldc #2）时，该字符串才会被创建并放入串池中。

使用拼接字符串变量对象创建字符串的过程

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a";
		String b = "b";
		String ab = "ab";
		//拼接字符串对象来创建新的字符串
		String ab2 = a+b; 
	}
}

反编译后的结果

	 Code:
      stack=2, locals=5, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: new           #5                  // class java/lang/StringBuilder
        12: dup
        13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
        16: aload_1
        17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
        27: astore        4
        29: return

通过拼接的方式来创建字符串的过程是：StringBuilder().append(“a”).append(“b”).toString()

最后的toString方法的返回值是一个新的字符串，但字符串的值和拼接的字符串一致，但是两个不同的字符串，一个存在于串池之中，一个存在于堆内存之中

String ab = "ab";
String ab2 = a+b;
//结果为false,因为ab是存在于串池之中，ab2是由StringBuffer的toString方法所返回的一个对象，存在于堆内存之中
System.out.println(ab == ab2);

使用拼接字符串常量对象的方法创建字符串

public class StringTableStudy {
	public static void main(String[] args) {
		String a = "a";
		String b = "b";
		String ab = "ab";
		String ab2 = a+b;
		//使用拼接字符串的方法创建字符串
		String ab3 = "a" + "b";
	}
}

反编译后的结果

 	  Code:
      stack=2, locals=6, args_size=1
         0: ldc           #2                  // String a
         2: astore_1
         3: ldc           #3                  // String b
         5: astore_2
         6: ldc           #4                  // String ab
         8: astore_3
         9: new           #5                  // class java/lang/StringBuilder
        12: dup
        13: invokespecial #6                  // Method java/lang/StringBuilder."<init>":()V
        16: aload_1
        17: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        20: aload_2
        21: invokevirtual #7                  // Method java/lang/StringBuilder.append:(Ljava/lang/String
;)Ljava/lang/StringBuilder;
        24: invokevirtual #8                  // Method java/lang/StringBuilder.toString:()Ljava/lang/Str
ing;
        27: astore        4
        //ab3初始化时直接从串池中获取字符串
        29: ldc           #4                  // String ab
        31: astore        5
        33: return
  • 使用拼接字符串常量的方法来创建新的字符串时，因为内容是常量，javac在编译期会进行优化，结果已在编译期确定为ab，而创建ab的时候已经在串池中放入了“ab”，所以ab3直接从串池中获取值，所以进行的操作和 ab = “ab” 一致。
  • 使用拼接字符串变量的方法来创建新的字符串时，因为内容是变量，只能在运行期确定它的值，所以需要使用StringBuilder来创建
intern()方法JDK 1.8

调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

  • 如果串池中没有该字符串对象，则放入成功
  • 如果有该字符串对象，则放入失败
  • 无论放入是否成功，都会返回串池中的字符串对象

注意：此时如果调用intern方法成功，堆内存与串池中的字符串对象是同一个对象；如果失败，则不是同一个对象

例1

public class Main {
	public static void main(String[] args) {
		//"a" "b" 被放入串池中，str则存在于堆内存之中
		String str = new String("a") + new String("b");
		//调用str的intern方法，这时串池中没有"ab"，则会将该字符串对象放入到串池中，此时堆内存与串池中的"ab"是同一个对象
		String st2 = str.intern();
		//给str3赋值，因为此时串池中已有"ab"，则直接将串池中的内容返回
		String str3 = "ab";
		//因为堆内存与串池中的"ab"是同一个对象，所以以下两条语句打印的都为true
		System.out.println(str == st2);
		System.out.println(str == str3);
	}
}

例2

public class Main {
	public static void main(String[] args) {
        //此处创建字符串对象"ab"，因为串池中还没有"ab"，所以将其放入串池中
		String str3 = "ab";
        //"a" "b" 被放入串池中，str则存在于堆内存之中
		String str = new String("a") + new String("b");
        //此时因为在创建str3时，"ab"已存在与串池中，所以放入失败，但是会返回串池中的"ab"
		String str2 = str.intern();
        //false
		System.out.println(str == str2);
        //false
		System.out.println(str == str3);
        //true
		System.out.println(str2 == str3);
	}
}
intern()方法JDK 1.6

调用字符串对象的intern方法，会将该字符串对象尝试放入到串池中

  • 如果串池中没有该字符串对象，会将该字符串对象复制一份，再放入到串池中
  • 如果有该字符串对象，则放入失败
  • 无论放入是否成功，都会返回串池中的字符串对象

注意：此时无论调用intern方法成功与否，串池中的字符串对象和堆内存中的字符串对象都不是同一个对象

StringTable 垃圾回收

StringTable在内存紧张时，会发生垃圾回收

StringTable调优

  • 因为StringTable是由HashTable实现的，所以可以适当增加HashTable桶的个数，来减少字符串放入串池所需要的时间
-XX:StringTableSize=xxxx
  • 考虑是否需要将字符串对象入池
    可以通过 intern() 方法减少重复入池

6、直接内存

  • 属于操作系统，常见于NIO操作时，用于数据缓冲区
  • 分配回收成本较高，但读写性能高
  • 不受JVM内存回收管理

文件读写流程

在这里插入图片描述
使用了DirectBuffer
在这里插入图片描述
直接内存是操作系统和Java代码都可以访问的一块区域，无需将代码从系统内存复制到Java堆内存，从而提高了效率!!

释放原理

直接内存的回收不是通过JVM的垃圾回收来释放的，而是通过unsafe.freeMemory来手动释放

通过

//通过ByteBuffer申请1M的直接内存
ByteBuffer byteBuffer = ByteBuffer.allocateDirect(_1M);

申请直接内存，但JVM并不能回收直接内存中的内容，它是如何实现回收的呢？

allocateDirect的实现

public static ByteBuffer allocateDirect(int capacity) {
    return new DirectByteBuffer(capacity);
}

DirectByteBuffer类

DirectByteBuffer(int cap) {   // package-private
   
    super(-1, 0, cap, cap);
    boolean pa = VM.isDirectMemoryPageAligned();
    int ps = Bits.pageSize();
    long size = Math.max(1L, (long)cap + (pa ? ps : 0));
    Bits.reserveMemory(size, cap);

    long base = 0;
    try {
        base = unsafe.allocateMemory(size); //申请内存
    } catch (OutOfMemoryError x) {
        Bits.unreserveMemory(size, cap);
        throw x;
    }
    unsafe.setMemory(base, size, (byte) 0);
    if (pa && (base % ps != 0)) {
        // Round up to page boundary
        address = base + ps - (base & (ps - 1));
    } else {
        address = base;
    }
    cleaner = Cleaner.create(this, new Deallocator(base, size, cap)); //通过虚引用，来实现直接内存的释放，this为虚引用的实际对象
    att = null;
}

这里调用了一个Cleaner的create方法，且后台线程还会对虚引用的对象监测，如果虚引用的实际对象（这里是DirectByteBuffer）被回收以后，就会调用Cleaner的clean方法，来清除直接内存中占用的内存

public void clean() {
       if (remove(this)) {
           try {
               this.thunk.run(); //调用run方法
           } catch (final Throwable var2) {
               AccessController.doPrivileged(new PrivilegedAction<Void>() {
                   public Void run() {
                       if (System.err != null) {
                           (new Error("Cleaner terminated abnormally", var2)).printStackTrace();
                       }

                       System.exit(1);
                       return null;
                   }
               });
           }

对应对象的run方法

public void run() {
    if (address == 0) {
        // Paranoia
        return;
    }
    unsafe.freeMemory(address); //释放直接内存中占用的内存
    address = 0;
    Bits.unreserveMemory(size, capacity);
}
直接内存的回收机制总结
  • 使用了Unsafe类来完成直接内存的分配回收，回收需要主动调用freeMemory方法
  • ByteBuffer的实现内部使用了Cleaner（虚引用）来检测ByteBuffer。一旦ByteBuffer被垃圾回收，那么会由ReferenceHandler来调用Cleaner的clean方法调用freeMemory来释放内存

三、垃圾回收 （GC）

1、如何判断对象可以回收

引用计数法

弊端：循环引用时，两个对象的计数都为1，导致两个对象都无法被释放
在这里插入图片描述

可达性分析算法

  • JVM中的垃圾回收器通过可达性分析来探索所有存活的对象
  • 扫描堆中的对象，看能否沿着GC Root对象为起点的引用链找到该对象，如果找不到，则表示可以回收
  • 可以作为GC Root的对象
    （1）虚拟机栈（栈帧中的本地变量表）中引用的对象。　
    （2）方法区中类静态属性引用的对象
    （3）方法区中常量引用的对象
    （4）本地方法栈中JNI（即一般说的Native方法）引用的对象

五种引用

在这里插入图片描述

强引用

只有GC Root都不引用该对象时，才会回收强引用对象

  • 如上图B、C对象都不引用A1对象时，A1对象才会被回收
软引用

当GC Root指向软引用对象时，在内存不足时，会回收软引用所引用的对象

  • 如上图如果B对象不再引用A2对象且内存不足时，软引用所引用的A2对象就会被回收

软引用的使用

public class Demo1 {
	public static void main(String[] args) {
		final int _4M = 4*1024*1024;
		//使用软引用对象 list和SoftReference是强引用，而SoftReference和byte数组则是软引用
		List<SoftReference<byte[]>> list = new ArrayList<>();
		SoftReference<byte[]> ref= new SoftReference<>(new byte[_4M]);
	}
}

如果在垃圾回收时发现内存不足，在回收软引用所指向的对象时，软引用本身不会被清理

如果想要清理软引用，需要使用引用队列

public class Demo1 {
	public static void main(String[] args) {
		final int _4M = 4*1024*1024;
		//使用引用队列，用于移除引用为空的软引用对象
		ReferenceQueue<byte[]> queue = new ReferenceQueue<>();
		//使用软引用对象 list和SoftReference是强引用，而SoftReference和byte数组则是软引用
		List<SoftReference<byte[]>> list = new ArrayList<>();
		SoftReference<byte[]> ref= new SoftReference<>(new byte[_4M]);

		//遍历引用队列，如果有元素，则移除
		Reference<? extends byte[]> poll = queue.poll();
		while(poll != null) {
			//引用队列不为空，则从集合中移除该元素
			list.remove(poll);
			//移动到引用队列中的下一个元素
			poll = queue.poll();
		}
	}
}

大概思路为： 查看引用队列中有无软引用，如果有，则将该软引用从存放它的集合中移除（这里为一个list集合）

弱引用

只有弱引用引用该对象时，在垃圾回收时，无论内存是否充足，都会回收弱引用所引用的对象

  • 如上图如果B对象不再引用A3对象，则A3对象会被回收

弱引用的使用和软引用类似，只是将 SoftReference 换为了 WeakReference

虚引用

当虚引用对象所引用的对象被回收以后，虚引用对象就会被放入引用队列中，调用虚引用的方法

  • 虚引用的一个体现是释放直接内存所分配的内存，当引用的对象ByteBuffer被垃圾回收以后，虚引用对象Cleaner就会被放入引用队列中，然后调用Cleaner的clean方法来释放直接内存
  • 如上图，B对象不再引用ByteBuffer对象，ByteBuffer就会被回收。但是直接内存中的内存还未被回收。这时需要将虚引用对象Cleaner放入引用队列中，然后调用它的clean方法来释放直接内存
终结器引用

所有的类都继承自Object类，Object类有一个finalize方法。当某个对象不再被其他的对象所引用时，会先将终结器引用对象放入饮用队列中，然后根据终结器引用对象找到它所引用的对象，然后调用该对象的finalize方法。调用以后，该对象就可以被垃圾回收了

  • 如上图，B对象不再引用A4对象。这是终结器对象就会被放入引用队列中，引用队列会根据它，找到它所引用的对象。然后调用被引用对象的finalize方法。调用以后，该对象就可以被垃圾回收了
引用队列
  • 软引用和弱引用可以配合引用队列
    在弱引用和虚引用所引用的对象被回收以后，会将这些引用放入引用队列中，方便一起回收这些软/弱引用对象
  • 虚引用和终结器引用必须配合引用队列
    虚引用和终结器引用在使用时会关联一个引用队列

2.垃圾回收算法

标记-清除

在这里插入图片描述
定义：标记清除算法顾名思义，是指在虚拟机执行垃圾回收的过程中，先采用标记算法确定可回收对象，然后垃圾收集器根据标识清除相应的内容，给堆内存腾出相应的空间

  • 这里的腾出内存空间并不是将内存空间的字节清0，而是记录下这段内存的起始结束地址，下次分配内存的时候，会直接覆盖这段内存

缺点：容易产生大量的内存碎片 可能无法满足大对象的内存分配，一旦导致无法分配对象，那就会导致jvm启动gc，一旦启动gc，我们的应用程序就会暂停，这就导致应用的响应速度变慢

标记-整理

在这里插入图片描述
标记-整理 会将不被GC Root引用的对象回收，清楚其占用的内存空间。然后整理剩余的对象，可以有效避免因内存碎片而导致的问题，但是因为整体需要消耗一定的时间，所以效率较低

复制

在这里插入图片描述
在这里插入图片描述
将内存分为等大小的两个区域，FROM和TO（TO中为空）。先将被GC Root引用的对象从FROM放入TO中，再回收不被GC Root引用的对象。然后交换FROM和TO。这样也可以避免内存碎片的问题，但是会占用双倍的内存空间。

3.分代回收

在这里插入图片描述

回收流程

新创建的对象都被放在了新生代的伊甸园中

在这里插入图片描述
当伊甸园中的内存不足时，就会进行一次垃圾回收，这时的回收叫做 Minor GC

Minor GC 会将伊甸园和幸存区FROM存活的对象先复制到 幸存区 TO中， 并让其寿命加1，再交换两个幸存区

在这里插入图片描述
再次创建对象，若新生代的伊甸园又满了，则会再次触发 Minor GC（会触发 stop the world， 暂停其他用户线程，只让垃圾回收线程工作），这时不仅会回收伊甸园中的垃圾，还会回收幸存区中的垃圾，再将活跃对象复制到幸存区TO中。回收以后会交换两个幸存区，并让幸存区中的对象寿命加1
在这里插入图片描述
如果幸存区中的对象的寿命超过某个阈值（最大为15，4bit），就会被放入老年代中
在这里插入图片描述
如果新生代老年代中的内存都满了，就会先出法Minor Gc，再触发Full GC，扫描新生代和老年代中所有不再使用的对象并回收

GC 分析

大对象处理策略

当遇到一个较大的对象时，就算新生代的伊甸园为空，也无法容纳该对象时，会将该对象直接晋升为老年代

线程内存溢出

某个线程的内存溢出了而抛异常（out of memory），不会让其他的线程结束运行

这是因为当一个线程抛出OOM异常后，它所占据的内存资源会全部被释放掉，从而不会影响其他线程的运行，进程依然正常

4.垃圾回收器

相关概念

并行收集： 指多条垃圾收集线程并行工作，但此时用户线程仍处于等待状态。

并发收集： 指用户线程与垃圾收集线程同时工作（不一定是并行的可能会交替执行）。用户程序在继续运行，而垃圾收集程序运行在另一个CPU上

吞吐量： 即CPU用于运行用户代码的时间与CPU总消耗时间的比值（吞吐量 = 运行用户代码时间 / ( 运行用户代码时间 + 垃圾收集时间 )），也就是。例如：虚拟机共运行100分钟，垃圾收集器花掉1分钟，那么吞吐量就是99%

串行

  • 单线程
  • 内存较小，个人电脑（CPU核数较少）
    在这里插入图片描述
    **安全点：**让其他线程都在这个点停下来，以免垃圾回收时移动对象地址，使得其他线程找不到被移动的对象因为是串行的，所以只有一个垃圾回收线程。且在该线程执行回收工作时，其他线程进入阻塞状态
Serial 收集器

Serial收集器是最基本的、发展历史最悠久的收集器

特点： 单线程、简单高效（与其他收集器的单线程相比），采用复制算法。对于限定单个CPU的环境来说，Serial收集器由于没有线程交互的开销，专心做垃圾收集自然可以获得最高的单线程手机效率。收集器进行垃圾回收时，必须暂停其他所有的工作线程，直到它结束（Stop The World）

ParNew 收集器

ParNew收集器其实就是Serial收集器的多线程版本

特点： 多线程、ParNew收集器默认开启的收集线程数与CPU的数量相同，在CPU非常多的环境中，可以使用-XX:ParallelGCThreads参数来限制垃圾收集的线程数。和Serial收集器一样存在Stop The World问题

Serial Old 收集器

Serial Old是Serial收集器的老年代版本

特点： 同样是单线程收集器，采用标记-整理算法

吞吐量优先

  • 多线程
  • 堆内存较大，多核CPU
  • 单位时间内，STW（stop the world，停掉其他所有工作线程）时间最短
  • JDK1.8默认使用的垃圾回收器
    在这里插入图片描述
Parallel Scavenge 收集器

与吞吐量关系密切，故也称为吞吐量优先收集器

特点：属于新生代收集器也是采用复制算法的收集器（用到了新生代的幸存区），又是并行的多线程收集器（与ParNew收集器类似）

该收集器的目标是达到一个可控制的吞吐量。还有一个值得关注的点是：GC自适应调节策略（与ParNew收集器最重要的一个区别）

GC自适应调节策略：Parallel Scavenge收集器可设置-XX:+UseAdptiveSizePolicy参数。当开关打开时不需要手动指定新生代的大小（-Xmn）、Eden与Survivor区的比例（-XX:SurvivorRation）、晋升老年代的对象年龄（-XX:PretenureSizeThreshold）等，虚拟机会根据系统的运行状况收集性能监控信息，动态设置这些参数以提供最优的停顿时间和最高的吞吐量，这种调节方式称为GC的自适应调节策略。

Parallel Scavenge收集器使用两个参数控制吞吐量：

  • XX:MaxGCPauseMillis 控制最大的垃圾收集停顿时间
  • XX:GCRatio 直接设置吞吐量的大小
Parallel Old 收集器

是Parallel Scavenge收集器的老年代版本

特点：多线程，采用标记-整理算法（老年代没有幸存区）

响应时间优先

  • 多线程
  • 堆内存较大，多核CPU
  • 尽可能让单次STW时间变短（尽量不影响其他线程运行）
    在这里插入图片描述
CMS 收集器

Concurrent Mark Sweep，一种以获取最短回收停顿时间为目标的老年代收集器

特点：基于标记-清除算法实现。并发收集、低停顿，但是会产生内存碎片

应用场景：适用于注重服务的响应速度，希望系统停顿时间最短，给用户带来更好的体验等场景下。如web程序、b/s服务

CMS收集器的运行过程分为下列4步：

（1）初始标记：标记GC Roots能直接到的对象。速度很快但是仍存在Stop The World问题

（2）并发标记：进行GC Roots Tracing 的过程，找出存活对象且用户线程可并发执行

（3）重新标记：为了修正并发标记期间因用户程序继续运行而导致标记产生变动的那一部分对象的标记记录。仍然存在Stop The World问题

（4）并发清除：对标记的对象进行清除回收

CMS收集器的内存回收过程是与用户线程一起并发执行的

G1

定义

Garbage First

JDK 9以后默认使用，而且替代了CMS 收集器
在这里插入图片描述

适用场景
  • 同时注重吞吐量和低延迟（响应时间）
  • 超大堆内存（内存大的），会将堆内存划分为多个大小相等的区域
  • 整体上是标记-整理算法，两个区域之间是复制算法

相关参数：JDK8 并不是默认开启的，所需要参数开启
在这里插入图片描述

G1垃圾回收阶段

在这里插入图片描述
新生代伊甸园垃圾回收—–>内存不足，新生代回收+并发标记—–>回收新生代伊甸园、幸存区、老年代内存——>新生代伊甸园垃圾回收(重新开始)

5.GC 调优

查看虚拟机参数命令

//可以根据参数去查询具体的信息
"F:\JAVA\JDK8.0\bin\java" -XX:+PrintFlagsFinal -version | findstr "GC"

调优领域

  • 内存
  • 锁竞争
  • CPU占用
  • IO
  • GC

确定目标

低延迟/高吞吐量？ 选择合适的GC

  • CMS G1 ZGC
  • ParallelGC
  • Zing

最快的GC是不发生GC

首先排除减少因为自身编写的代码而引发的内存问题

  • 查看Full GC前后的内存占用，考虑以下几个问题
    （1）数据是不是太多？
    （2）数据表示是否太臃肿
    （3）是否存在内存泄漏

新生代调优

1. 新生代的特点

  • 所有的new操作分配内存都是非常廉价的
  • 死亡对象回收零代价
  • 大部分对象用过即死（朝生夕死）
  • MInor GC 所用时间远小于Full GC

2. 新生代内存越大越好么？ （不是）

  • 新生代内存太小：频繁触发Minor GC，会STW，会使得吞吐量下降
  • 新生代内存太大：老年代内存占比有所降低，会更频繁地触发Full GC。而且触发Minor GC时，清理新生代所花费的时间会更长

新生代内存设置为内容纳[并发量(请求-响应)]的数据为宜*

幸存区调优

  • 幸存区需要能够保存 当前活跃对象+需要晋升的对象
  • 晋升阈值配置得当，让长时间存活的对象尽快晋升

老年代调优

可以设置Full GC参数为0 即 老年代一有垃圾就清理

meowyf
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JVM学习总结
03-08
多进程，多线程，并发，并行： 1.多进程，同时打开word,excel,ppt 2.多进程，迅雷同时下载多个资源 3.并发Concurrency，一个cpu在多个线程之间复用。所有并发处理都会经历排 队等候，唤醒，执行等步骤。...
JVM入门学习
Cguoer的博客
02-23 2088
一、JVM的位置 程序通过java XX.class运行，这个命令是JRE的命令，JRE中包括JVM，而JRE是建立在操作系统上使用的，操作系统又是基于硬件为基础的。 二、jvm的体系结构 详细体系结构： 三、类加载器 这里的Car.class是.class文件，经过类加载器进行加载和初始化变成Class类，再通过实例化变为对象。 Class Loader的三个阶段（类加载的三个阶段） 1.加载阶段 将编译好的class文件加载到内存中（方法区），然后会生成一个代表这个类的Class对象。
JVM详细学习
qq_52574792的博客
01-31 774
会移动到老年代。老年代是存储长期存活的对象的，占满时就会触发我们最常听说的Full GC，期间会停止所有线程等待GC的完成。所以对于响应要求高的应用应该尽量去减少发生Full GC从而避免响应超时的问题。而且当老年区执行了full gc之后仍然无法进行对象保存的操作，就会产生OOM，这时候就是虚拟机中的堆内存不足，原因可能会是堆内存设置的大小过小，这个可以通过参数-Xms、-Xmx来调整。也可能是代码中创建的对象大且多，而且它们一直在被引用从而长时间垃圾收集无法收集它们。
jvm的学习
程序猿的十万个为什么
12-01 974
一、jvm的位置 JVM是运行在操作系统之上的，它与硬件没有直接的交互 二、jvmt体系结构 ①程序计数器 (1)程序计数器是一块较小的内存空间，是当前线程所执行的字节码的行号指示器，字节码解释器工作时是通过改变这个计数器的值来选取下一条需要执行的字节码（包括分支、循环、跳转、异常处理、线程恢复） (2)java虚拟机多线程是通过线程轮流切换分配处理器执行时间，为了多线程切换后能...
JVM知识点总结
day_ue的博客
07-04 886
VM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台上不加修改地运行。JVM在执行字节码时，实际上最终还是把字节码解释成具体平台上的机器指令执行。
JVM学习笔记
04-28
从JVM内存模型、常用JVM参数、垃圾回收算法和垃圾回收器等几个角度学习JVM
JVM 学习笔记
05-28
NULL 博文链接：https://cooldatabase.iteye.com/blog/634599
jvm学习路线图
05-04
jvm学习路线图，可以供初步想学习的同学了解学习。。。
jvm学习心路历程.jpg
07-07
按照目录指示学习，收获会很大哦
JVM详解，让你一文吃透
最新发布
深圳市多克创新科技有限公司
10-12 956
你比别人强的地方，不是你做过多少年的CRUD工作，而是你比别人掌握了更多深入的技能。不要总停留在CRUD的表面工作，理解并掌握底层原理并熟悉源码实现，并形成自己的抽象思维能力，做到灵活运用，才是你突破瓶颈，脱颖而出的重要方向！ 你在刷抖音，玩游戏的时候，别人都在这里学习，成长，提升，人与人最大的差距其实就是思维。你可能不信，优秀的人，总是在一起
JVM知识点（全，一篇搞定）
qq_35462834的博客
12-10 2440
1、什么是JVM JVM是Java程序运行的平台，它就像一台虚拟出来的计算机一样，负责执行Java编译好的字节码文件。JVM具有非常严格的实现规范，大多数操作系统都可以安装JVM，为Java语言的跨平台性起到了关键的作用。 JVM（Java虚拟机）是一个想象中的机器，在实际的计算机上通过软件模拟来实现。Java虚拟机有自己想象的硬件，堆栈，寄存器等，还具有相应的指令系统。
JVM 学习
cmdos的专栏
03-19 236
JVM 学习一、JVM 概念1.1、JVM 定义JVM 是 Java Virtual Machine（Java虚拟机）的缩写,它是一个虚拟的计算机,是java编译后文件的运行环境java语言一个非常重要的特性就是与平台无关性，JVM 是实现这一特性的关键。Java语言使用JVM虚拟机屏蔽了与平台交互的具体细节，使得java语言编译程序只需在java虚拟机上运行目标代码（字节码），就可以在不同平台不加修改地运行。JVM在执行字节码时，把字节码解释成具体平台上的机器指令执行，这就是为什么java能'一次编译,到
【Java】JVM学习
X_xiaojuzi的博客
08-08 401
Java虚拟机的启动是通过引导类加载器（bootstrap class loader）创建一个初始类（initial class）来完成的，这个类是由虚拟机的具体实现指定的。4. 某线程调用Runtime类或System类的exit()方法，或Runtime类的halt()方法，并且Java安全管理器也允许这次exit()或halt()操作。3、Java技术的核心就是Java虚拟机（JVM，Java Virtual Machine），因为所有的Java程序都运行在Java虚拟机内部。............
JVM 基本知识
kim的博客
04-27 1266
JVM。
JVM基础和常见面试题
皓亮君的博客
09-29 2318
JVM是JavaVirtualMachine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java是一门抽象程度特别高的语言，提供了自动内存管理等一系列的特性。这些特性直接在操作系统上实现是不太可能的，所以就需要JVM进行一番转换。从下图中可以看到，有了JVM这个抽象层之后，Java就可以实现跨平台了。JVM只需要保证能够正确执行.class文件，就可以运行在诸如Linux、Windows、MacOS等平台上了。
jvm学习
prettyboy2ge的博客
04-15 797
一，初识jvm jvm java virtual machine 顾名思义java虚拟机。 用于执行jvm规范的代码的。也是java跨平台的实现支撑。 二，jvm知识体系 内存结构是jvm核心内容。其他，垃圾回收，性能调优，JVM自身优化技术，执行引擎， 监控工具，类文件结构，类加载。都需要围绕内存结构。 二.一内存模型。 java运行时的数据区被java直接管理的区域叫运行时数据区，java将这个区域划分为了不同的区域。 没被java管理的部分是操作系统的直接内存必须操作.
JVM学习最全概念
m0_61453973的博客
06-09 153
ｊｖｍ体系结构、类加载器、运行时数据区、执行引擎、本地方法接口、垃圾回收及相关算法
宋红康jvm学习笔记 逃逸分析
05-19
逃逸分析是JVM在运行时对对象的分析，用于确定对象的作用域。如果对象只在方法内部使用，那么它就不会逃逸出该方法，否则就会逃逸。逃逸分析可以优化程序的性能，因为当对象不逃逸时，JVM可以将它们放在线程栈上分配...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值