JVM篇——性能调优专题

帕尔西斯

已于 2023-04-24 22:35:22 修改

阅读量512

点赞数 5

分类专栏： JAVA老本行文章标签： jvm java kafka mybatis tomcat

于 2023-03-15 17:35:29 首次发布

本文链接：https://blog.csdn.net/RUST_911/article/details/129553256

版权

JAVA老本行专栏收录该内容

3 篇文章 0 订阅

订阅专栏

只要你是java学习者，那jvm将是你绕不过的槛。加油学习，奥里给！！！

文章目录

JVM调优篇

数据存在数据库中时，是离散的存储，数据表中相邻的字段存储位置并不相邻，因此在顺序查找字段时需要一个一个查找，这是很大的io消耗。因此需要降低io引入数据结构，二叉树，红黑树，b树，哈希表等。

JVM调优篇

从JDK源码级别剖析JVM类加载机制

JVM创建加载流程
在这里插入图片描述
ps：1.图中c++的jvm.dll就类似java中的jar包
2. 上图中的Launcher类是所有类加载器的启动器

其中loadClass的类加载过程有如下几步：
加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载

加载：在硬盘上查找并通过IO读入字节码文件，使用到类时才会加载，例如调用类的main()方法，new对象等等，在加载阶段会在内存中生成一个代表这个类的java.lang.Class对象，作为方法区这个类的各种数据的访问入口
验证：校验字节码文件的正确性（cafe babe）
准备：给类的静态变量分配内存，并赋予默认值
解析：将符号引用替换为直接引用，该阶段会把一些静态方法(符号引用，比如main()方法)替换为指向数据所存内存的指针或句柄等(直接引用)，这是所谓的静态链接过程(类加载期间完成)，动态链接是在程序运行期间完成的将符号引用替换为直接引用
初始化：对类的静态变量初始化为指定的值，执行静态代码块

类加载流程：
在这里插入图片描述
可以使用javap -v Math.class 指令来查看解析的符号(字面量)，这些与字节码文件是一一对应的。

public class TestDynamicLoad {

static {
	System.out.println("*************load TestDynamicLoad************");
}

public static void main(String[] args) {
	new A();
	System.out.println("*************load test************");
	B b = null; //B不会加载，除非这里执行 new B()
}
}

class A {
	static {
		System.out.println("*************load A************");
	}
	
	 public A() {
	 	System.out.println("*************initial A************");
	 }
 }

 class B {
	 static {
	 	System.out.println("*************load B************");
	 }
	
	 public B() {
	 	System.out.println("*************initial B************");
	 }
 }

 运行结果：
 *************load TestDynamicLoad************
 *************load A************
 *************initial A************
 *************load test************

程序运行时，所依赖的war包都会被加载使用吗？
不会加载，因为是用懒加载实现的。
先load主类 -->加载被new的类（类似B b=null的B类并不会加载，静态代码块也不会执行）

类加载器和双亲委派机制
上面的类加载过程主要是通过类加载器来实现的，Java里有如下几种类加载器

引导类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的核心类库，比如rt.jar、charsets.jar等（C++实现，故String.class.getClassLoader()返回的是null，因为加载器不是java对象）
扩展类加载器：负责加载支撑JVM运行的位于JRE的lib目录下的ext扩展目录中的JAR类包
应用程序类加载器：负责加载ClassPath路径下的类包，主要就是加载你自己写的那些类
自定义加载器：负责加载用户自定义路径下的类包

在这里插入图片描述
双亲委派机制说简单点就是，先找父亲加载，不行再由儿子自己加载

1.一般加载在项目目录下的/terget目录下
2.加载器之间为父子加载器关系，而不是父子类关系（无继承关系）。所有类加载器都继承自ClassLoader类，APP/EXTRA~ 继承自 URL~ 继承自 SECURE~ 继承自 ClassLoader。
源码关键方法：
findLoadedClass(name)：检查请求的类是否已经被加载过了（类加载器的存储空间）

已经加载过的类会存放在加载它的的类加载器的内存中

findClass（）：真正加载类的逻辑，通过类加载路径找到类，并defineClass()( 重写就是自定义类加载器 )
loadClass（String,Boolean）：如果父类加载器加载失败则会调用自定义的findClass方法( 重写就是打破双亲委派 ) 嵌套向上
defineClass(): 把类字节数组变成类

为什么要设计双亲委派机制？

沙箱安全机制：自己写的java.lang.String.class类不会被加载，这样便可以防止核心API库被随意篡改
避免类的重复加载：当父亲已经加载了该类时，就没有必要子ClassLoader再加载一次，保证被加载类的唯一性

全盘负责委托机制
“全盘负责”是指当一个ClassLoder装载一个类时，除非显示的使用另外一个ClassLoder，该类所依赖及引用的类也由这个ClassLoder载入。

自定义类加载器示例：
自定义类加载器只需要继承 java.lang.ClassLoader 类，该类有两个核心方法，一个是loadClass(String, boolean)，实现了双亲委派机制，还有一个方法是findClass，默认实现是空方法，所以我们自定义类加载器主要是重写findClass方法。

public class MyClassLoaderTest {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name
                    + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;
        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                //defineClass将一个字节数组转为Class对象，这个字节数组是class文件读取后最终的字节数组。
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

    }

    public static void main(String args[]) throws Exception {
        //初始化自定义类加载器，会先初始化父类ClassLoader，其中会把自定义类加载器的父加载器设置为应用程序类加载器AppClassLoader
        MyClassLoader classLoader = new MyClassLoader("D:/test");
        //D盘创建 test/com/tuling/jvm 几级目录，将User类的复制类User1.class丢入该目录
        Class clazz = classLoader.loadClass("com.tuling.jvm.User1");
        Object obj = clazz.newInstance();
        Method method = clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

运行结果：
=======自己的加载器加载类调用方法=======
com.tuling.jvm.MyClassLoaderTest$MyClassLoader

打破双亲委派机制
再来一个沙箱安全机制示例，尝试打破双亲委派机制，用自定义类加载器加载我们自己实现的 java.lang.String.class

public class MyClassLoaderTest {
    static class MyClassLoader extends ClassLoader {
        private String classPath;

        public MyClassLoader(String classPath) {
            this.classPath = classPath;
        }

        private byte[] loadByte(String name) throws Exception {
            name = name.replaceAll("\\.", "/");
            FileInputStream fis = new FileInputStream(classPath + "/" + name
                    + ".class");
            int len = fis.available();
            byte[] data = new byte[len];
            fis.read(data);
            fis.close();
            return data;

        }

        protected Class<?> findClass(String name) throws ClassNotFoundException {
            try {
                byte[] data = loadByte(name);
                return defineClass(name, data, 0, data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new ClassNotFoundException();
            }
        }

        /**
         * 重写类加载方法，实现自己的加载逻辑，不委派给双亲加载
         * @param name
         * @param resolve
         * @return
         * @throws ClassNotFoundException
         */
        protected Class<?> loadClass(String name, boolean resolve)
                throws ClassNotFoundException {
            synchronized (getClassLoadingLock(name)) {
                // First, check if the class has already been loaded
                Class<?> c = findLoadedClass(name);

                if (c == null) {
                    // If still not found, then invoke findClass in order
                    // to find the class.
                    long t1 = System.nanoTime();
                    c = findClass(name);

                    // this is the defining class loader; record the stats
                    sun.misc.PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    sun.misc.PerfCounter.getFindClasses().increment();
                }
                if (resolve) {
                    resolveClass(c);
                }
                return c;
            }
        }
    }

    public static void main(String args[]) throws Exception {
        MyClassLoader classLoader = new MyClassLoader("D:/test");
        //尝试用自己改写类加载机制去加载自己写的java.lang.String.class
        Class clazz = classLoader.loadClass("java.lang.String");
        Object obj = clazz.newInstance();
        Method method= clazz.getDeclaredMethod("sout", null);
        method.invoke(obj, null);
        System.out.println(clazz.getClassLoader().getClass().getName());
    }
}

运行结果：
java.lang.SecurityException: Prohibited package name: java.lang
	at java.lang.ClassLoader.preDefineClass(ClassLoader.java:659)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:758)

JVM内存模型深度剖析与优化

在这里插入图片描述
JDK>JRE>JSE>JVM
Java语言的跨平台特性

JVM层解决了不同机器机器码不同的问题。
.class文件丢到jvm内以后，实际执行时使用类似javap转成的可读性更强的指令。

1.C++实现的类装载子系统和字节码执行引擎，包括jvm的加载运行很多都是c++实现的，然后将类丢到内存区域，再有字节码执行引擎去执行代码

堆：一般来说new的对象放在堆上
栈(指向堆)：分配给线程存放局部变量(指向堆内的内存地址)
栈针内存空间：分配给每个方法的内存区域（将不同方法的区域隔离）
局部变量表，操作数栈——（遵循jvm指令操作方法执行）
动态链接
方法出口——执行完后回到哪一行代码，后续如何执行
程序计数器：存储的是方法执行中的jvm指令(istore_1,iload_0,bipush这种)对应的内存地址（每执行一个往后走一个）
方法区(指向堆)：常量池（运行时，八大基础类型，字符串）常量 + 静态变量 + 类信息
本地方法栈(用的少)：native方法，底层是c,c++实现的（dll文件）
重点：每个线程都有它自己的程序计数器，栈，本地方法栈（独有，不共享）

jvm visualvm：自带的jvm监控工具（可以清晰看到eden，s0，s1，old区的内存变化）

JVM内存参数设置 在这里插入图片描述

java ‐Xms2048M ‐Xmx2048M ‐Xmn1024M ‐Xss512K ‐XX:MetaspaceSize=256M ‐XX:MaxMetaspaceSize=256M ‐jar microservice‐eurek
a‐server.jar

关于元空间的JVM参数有两个：-XX:MetaspaceSize=N和 -XX:MaxMetaspaceSize=N

XX：MaxMetaspaceSize：设置元空间最大值，默认是-1，即不限制，或者说只受限于本地内存大小。
XX：MetaspaceSize：指定元空间触发Fullgc的初始阈值(元空间无固定初始大小)，以字节为单位，默认是21M，达到该值就会触发full gc进行类型卸载，同时收集器会对该值进行调整：如果释放了大量的空间，就适当降低该值；如果释放了很少的空间，那么在不超过-XX：MaxMetaspaceSize（如果设置了的话）的情况下，适当提高该值。这个跟早期jdk版本的-XX:PermSize参数意思不一样，-
XX:PermSize代表永久代的初始容量。
由于调整元空间的大小需要Full GC，这是非常昂贵的操作，如果应用在启动的时候发生大量Full GC，通常都是由于永久代或元空间发生了大小调整，基于这种情况，一般建议在JVM参数中将MetaspaceSize和MaxMetaspaceSize设置成一样的值，并设置得比初始值要大，对于8G物理内存的机器来说，一般我会将这两个值都设置为256M。

结论：
-Xss设置越小count值越小，说明一个线程栈里能分配的栈帧就越少，但是对JVM整体来说能开启的线程数会更多

JVM对象创建与内存分配机制深度剖析

在这里插入图片描述
1.类加载检查
虚拟机遇到一条new指令时，首先将去检查这个指令的参数是否能在常量池中定位到一个类的符号引用，并且检查这个符号引用代表的类是否已被加载、解析和初始化过。如果没有，那必须先执行相应的类加载过程。
new指令对应到语言层面上讲是，new关键词、对象克隆、对象序列化等。
2.分配内存
在类加载检查通过后，接下来虚拟机将为新生对象分配内存。对象所需内存的大小在类加载完成后便可完全确定，为对象分配空间的任务等同于把一块确定大小的内存从Java堆中划分出来。
这个步骤有两个问题：
1.如何划分内存。
2.在并发情况下，可能出现正在给对象A分配内存，指针还没来得及修改，对象B又同时使用了原来的指针来分配内存的情况。
划分内存的方法：（不同垃圾回收算法适用不同方式）

“指针碰撞”（Bump the Pointer）(默认用指针碰撞)
如果Java堆中内存是绝对规整的，所有用过的内存都放在一边，空闲的内存放在另一边，中间放着一个指针作为分界点的指示器，那所分配内存就仅仅是把那个指针向空闲空间那边挪动一段与对象大小相等的距离。
“空闲列表”（Free List）
如果Java堆中的内存并不是规整的，已使用的内存和空闲的内存相互交错，那就没有办法简单地进行指针碰撞了，虚拟机就必须维护一个列表，记录上哪些内存块是可用的，在分配的时候从列表中找到一块足够大的空间划分给对象实例，并更新列表上的记录

解决并发问题的方法：

CAS（compare and swap）
虚拟机采用CAS配上失败重试的方式保证更新操作的原子性来对分配内存空间的动作进行同步处理。
本地线程分配缓冲（Thread Local Allocation Buffer,TLAB）把内存分配的动作按照线程划分在不同的空间之中进行，即每个线程在Java堆中预先分配一小块内存。通过XX:+/UseTLAB参数来设定虚拟机是否使用TLAB(JVM会默认开启XX:+UseTLAB)，XX:TLABSize 指定TLAB大小。

3.初始化
内存分配完成后，虚拟机需要将分配到的内存空间都初始化为零值（不包括对象头），如果使用TLAB，这一工作过程也可以提前至TLAB分配时进行。这一步操作保证了对象的实例字段在Java代码中可以不赋初始值就直接使用，程序能访问到这些字段的数据类型所对应的零值。
4.设置对象头
初始化零值之后，虚拟机要对对象进行必要的设置，例如这个对象是哪个类的实例、如何才能找到类的元数据信息、对象的哈希码、对象的GC分代年龄等信息。这些信息存放在对象的对象头Object Header之中。
在HotSpot虚拟机中，对象在内存中存储的布局可以分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充（Padding）。 HotSpot虚拟机的对象头包括两部分信息，第一部分（Mark Word）用于存储对象自身的运行时数据，如哈希码（HashCode）、GC分代年龄、锁状态标志、线程持有的锁、偏向线程ID、偏向时间戳等。
对象头的另外一部分是类型指针（Klass Pointer,C++实现），即对象指向它的类元数据的指针，虚拟机通过这个指针来确定这个对象是哪个类的实例（开启指针压缩为4字节，未开启为8字节）。

在这里插入图片描述
5.执行方法
执行方法，即对象按照程序员的意愿进行初始化。对应到语言层面上讲，就是为属性赋值（注意，这与上面的赋零值不同，这是由程序员赋的值），和执行构造方法。

JVM字节码文件结构深度剖析

CA FE BA BE 每个一字节，16位，一个16进制由8位表示
次版本号 2字节
主版本号 2字节

常量池：各种常量信息（比如：类型+长度+数据utf-8）
class中的资源仓库，用于后续使用，节省资源
这是静态常量池，类加载时会加载到运行时常量池
string a=“a”+“b”，在保存时为ab，这就是编译的优化

Field——方法——指令
java一个类中最多包含65535个接口，因为接口数只有2字节表示。
这部分主要是对字节码有个整体的意识

垃圾收集器ParNew&CMS与底层三色标记算法详解

CMS（Concurrent Mark Sweep）收集器是一种以获取最短回收停顿时间为目标的收集器。它非常符合在注重用户体验的应用上使用，它是HotSpot虚拟机第一款真正意义上的并发收集器，它第一次实现了让垃圾收集线程与用户线程（基本上）同时工作。

初始标记：暂停所有的其他线程(STW)，并记录下gc roots直接能引用的对象，速度很快。
并发标记：并发标记阶段就是从GC Roots的直接关联对象开始遍历整个对象图的过程，这个过程耗时较长但是不需要停顿用户线程，可以与垃圾收集线程一起并发运行。因为用户程序继续运行，可能会有导致已经标记过的对象状态发生改变。
重新标记：重新标记阶段就是为了修正并发标记期间因为用户程序继续运行而导致标记产生变动的那一部分对象的标记记录，这个阶段的停顿时间一般会比初始标记阶段的时间稍长，远远比并发标记阶段时间短。主要用到三色标记里的增量更新算法(见下面详解)做重新标记。
并发清理：开启用户线程，同时GC线程开始对未标记的区域做清扫。这个阶段如果有新增对象会被标记为黑色不做任何处理(见下面三色标记算法详解)。
并发重置：重置本次GC过程中的标记数据

CMS的相关核心参数

-XX:+UseConcMarkSweepGC：启用cms
-XX:ConcGCThreads：并发的GC线程数
-XX:+UseCMSCompactAtFullCollection：FullGC之后做压缩整理（减少碎片）
-XX:CMSFullGCsBeforeCompaction：多少次FullGC之后压缩一次，默认是0，代表每次FullGC后都会压缩一次
-XX:CMSInitiatingOccupancyFraction: 当老年代使用达到该比例时会触发FullGC（默认是92，这是百分比）
-XX:+UseCMSInitiatingOccupancyOnly：只使用设定的回收阈值(-XX:CMSInitiatingOccupancyFraction设
定的值)，如果不指定，JVM仅在第一次使用设定值，后续则会自动调整
-XX:+CMSScavengeBeforeRemark：在CMS GC前启动一次minor gc，目的在于减少老年代对年轻代的引用，降低CMS GC的标记阶段时的开销，一般CMS的GC耗时 80%都在标记阶段
-XX:+CMSParallellnitialMarkEnabled：表示在初始标记的时候多线程执行，缩短STW
-XX:+CMSParallelRemarkEnabled：在重新标记的时候多线程执行，缩短STW;

垃圾收集底层算法实现
黑色：表示对象已经被垃圾收集器访问过，且这个对象的所有引用都已经扫描过。黑色的对象代表已经扫描过，它是安全存活的，如果有其他对象引用指向了黑色对象，无须重新扫描一遍。黑色对象不可能直接（不经过灰色对象）指向某个白色对象。
灰色：表示对象已经被垃圾收集器访问过，但这个对象上至少存在一个引用还没有被扫描过。
白色：表示对象尚未被垃圾收集器访问过。显然在可达性分析刚刚开始的阶段，所有的对象都是白色的，若在分析结束的阶段，仍然是白色的对象，即代表不可达。

垃圾收集器G1&ZGC详解

在这里插入图片描述

帕尔西斯

关注

5
点赞
踩
2

收藏

觉得还不错? 一键收藏
4
评论
JVM篇——性能调优专题

JVM创建加载流程ps：1.图中c++的jvm.dll就类似java中的jar包2. 上图中的Launcher类是所有类加载器的启动器其中loadClass的类加载过程有如下几步：加载 >> 验证 >> 准备 >> 解析 >> 初始化 >> 使用 >> 卸载类加载流程：可以使用javap -v Math.class 指令来查看解析的符号(字面量)，这些与字节码文件是一一对应的。类加载器和双亲委派机制上面的类加载过程主要是通过类加载器来实现的，Java里有如下几种类加载器双亲委派机制说简单
复制链接

扫一扫