JVM performance tuning 1

The illustration is as follows ：

javac com.tuling.jvm.Math.java
java com.tuling.jvm.Math
stay windows System West java.exe Called jvm.dll File creation Java virtual machine （C++ Realization ）, Create a bootloader instance (C++ Realization ), In addition to direct C++ A call , just so so C++ call java Code , establish JVM starter , example sun.misc.Launcher This class boot class loader is responsible for loading and creating other class loaders , adopt sun.misc.Launcher.getLauncher() Get the loader of the running class itself ClassLoader, It is AppClassLoader Example ,launcher.getClassLoader() call loadClass Load the class to run Math,classLoader.loadClass(“com.tuling.jvm.Math”), When loading is complete JVM Will execute Math Class main Method entrance ,Math.main(),java End of program running ！

among loadClass There are several steps in the class loading process of ： load >> verification >> Get ready >> analysis >> initialization >> Use >> uninstall load ： Find it on the hard disk and go through IO Read in bytecode file , It will not load until the class is used , For example, call the main() Method ,new Objects, etc. , In the loading phase, a representation of this class will be generated in memory java.lang.Class object , As the access to all kinds of data of this class in method area verification ： Check the correctness of bytecode file jvm Binary starts with cafe baby Get ready ： Allocating memory to static variables of a class , And give default values analysis ： Replace symbol references with direct references , This stage will put some static methods ( Symbol reference , such as main() Method ) Replace with a pointer or handle to the memory in which the data is stored ( Direct reference ), This is the so-called static link cheng ( Finished during class loading ), Dynamic linking is the replacement of a symbolic reference with a direct reference during program execution , Next This class will talk about dynamic links initialization ： Class static variables are initialized to the specified values , Execute static code block

1. The parental delegation mechanism can be broken

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);
                // Directly return the verification information , Don't look for  Resource res = ucp.getResource(path, false);
                // One less step in the process of finding classes from the parent class loader 
                // After loading , verification , Get ready , analysis , initialization , The bottom is c++ Realization 
                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();
                        // If it's not custom ClassLoader Take the parental delegation mechanism 
                        if(!name.startsWith("com.tuling.jvm")){
    
                           c = this.getParent().loadClass(name);
                        }else {
    
                            // Otherwise, directly load the class information to 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. How to break , What is the principle

 // If it's not custom ClassLoader Take the parental delegation mechanism 
                        if(!name.startsWith("com.tuling.jvm")){
    
                           c = this.getParent().loadClass(name);
                        }else {
    
                            // Otherwise, directly load the class information to jvm
                            c = findClass(name);

                        }



      byte[] data = loadByte(name);
                // Directly return the verification information , Don't look for  Resource res = ucp.getResource(path, false);
                // One less step in the process of finding classes from the parent class loader 
                // After loading , verification , Get ready , analysis , initialization , The bottom is c++ Realization 
                return defineClass(name,data,0,data.length);