JVM性能调优1

图解说明如下：

javac com.tuling.jvm.Math.java
java com.tuling.jvm.Math
在windows系统西java.exe调用的jvm.dll文件创建Java虚拟机（C++实现），创建一个引导类加载器实例(C++实现)，除了直接C++发起调用，还可以C++调用java代码，创建JVM启动器，实例sun.misc.Launcher该类引导类加载器负责加载创建其他类加载器，通过sun.misc.Launcher.getLauncher()获取运行类自己的加载器ClassLoader，它是AppClassLoader的实例，launcher.getClassLoader()调用loadClass加载要运行的类Math,classLoader.loadClass(“com.tuling.jvm.Math”),加载完成时候JVM会执行Math类的main方法入口，Math.main(),java程序运行结束！

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

1.双亲委派机制是可以打破的

package com.tuling.jvm;

import java.io.FileInputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Description:
 * Author: taimi 37310
 * Version: 1.0
 * Create Date Time: 2022/4/21 5:11.
 * Update Date Time:
 *
 * @see
 */
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(final String name)
                throws ClassNotFoundException {
            final Class<?> result;
            try {
                byte[] data = loadByte(name);
                //直接返回验证信息，不去查找 Resource res = ucp.getResource(path, false);
                //少一步从父类加载器中查找类的过程
                //加载后，验证，准备，解析，初始化，底层是c++实现
                return defineClass(name,data,0,data.length);
            } catch (Exception e) {
                e.printStackTrace();
                throw new 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) {
//                    long t0 = System.nanoTime();
//                    try {
//                        if (parent != null) {
//                            c = parent.loadClass(name, false);
//                        } else {
//                            c = findBootstrapClassOrNull(name);
//                        }
//                    } catch (ClassNotFoundException e) {
//                        // ClassNotFoundException thrown if class not found
//                        // from the non-null parent class loader
//                    }

                    if (c == null) {
                        // If still not found, then invoke findClass in order
                        // to find the class.
                        long t1 = System.nanoTime();
                        //如果不是自定义的ClassLoader走双亲委派机制
                        if(!name.startsWith("com.tuling.jvm")){
                           c = this.getParent().loadClass(name);
                        }else {
                            //否则直接加载类信息到jvm
                            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 ClassNotFoundException, IllegalAccessException, InstantiationException, NoSuchMethodException, InvocationTargetException {
            MyClassLoader classLoader = new MyClassLoader("D:/test");
            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());


        }
    }
}

2.如何打破，原理是什么

 //如果不是自定义的ClassLoader走双亲委派机制
                        if(!name.startsWith("com.tuling.jvm")){
                           c = this.getParent().loadClass(name);
                        }else {
                            //否则直接加载类信息到jvm
                            c = findClass(name);

                        }



      byte[] data = loadByte(name);
                //直接返回验证信息，不去查找 Resource res = ucp.getResource(path, false);
                //少一步从父类加载器中查找类的过程
                //加载后，验证，准备，解析，初始化，底层是c++实现
                return defineClass(name,data,0,data.length);