1. Overview of loading, linking and initializing of class

2. Class loading

1. JVM uses a parent delegation mechanism to load classloader on demand
2. After the class is loaded into the memory, the binary content of the class is stored in the Method Area of ​​the JVM, and a class object pointing to the content is also generated
3. The four levels of class loader, from top to bottom:

• Bootstrap: Load the core content of the JDK in the lib. If you call getClassLoader() to get null, it means that you have reached the top class loader
• Extension: Load various files in the extension package, the extension package is located in the JDK installation directory jre/lib/ext/*.jar
• Application: commonly used class loader, used to load the content specified by the classpath
• CustomClassLoader: custom class loader
  

4. Class loading process:
   

3. Custom ClassLoader

1. ClassLoader source code (key part)

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();
                    c = findClass(name);

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

2. How to customize the class loader

1. Inherit ClassLoader
2. Rewrite findClass(), call defineClass() in findClass() to implement encryption logic
3. To break the parental delegation, override loadClass()
4. An example of a custom ClassLoader is as follows

public class MyClassLoader extends ClassLoader {

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
    //class file is placed on D drive
        File f = new File("D:/test/", name.replace(".", "/").concat(".class"));
        try {
            FileInputStream fis = new FileInputStream(f);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            int b = 0;

            while ((b=fis.read()) !=0) {
                baos.write(b);
            }

            byte[] bytes = baos.toByteArray();
            baos.close();
            fis.close();

            return defineClass(name, bytes, 0, bytes.length);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return super.findClass(name); //throws ClassNotFoundException
    }

    public static void main(String[] args) throws Exception {
        ClassLoader classLoader = new MyClassLoader();
        Class clazz = classLoader.loadClass("com.wangxshen.test.HelloWorld");

        HelloWorld h = (HelloWorld)clazz.newInstance();
        h.m();

        System.out.println(classLoader.getClass().getClassLoader());
        System.out.println(classLoader.getParent());
        System.out.println(getSystemClassLoader());
    }
}

3. When to break parental delegation?

1. how? override loadClass()
2. when?

• Before JDK1.2, custom ClassLoader must override loadClass()
• ThreadContextClassLoader can implement the basic class call implementation class code, specified by thread.setContextClassLoader
• Use hot start and hot deployment when modularizing: osgi tomcat has its own classloader specified by the module, which can load into the class of the same name, breaking the parent delegation

4. Mixed mode

1. Interpreter: bytecode intepreter
2. JIT：Just In-Time compiler
3. Mixed mode: mix interpreter and hot code compilation

• Interpreted execution
• Hot code detection: 1. Methods that are called multiple times (method counter detection method execution frequency); 2. Loops called multiple times (loop counter detection cycle execution frequency); 3. Compile

4. VM options：

• -Xmixed: The default is mixed mode
• -Xint: Use the interpretation mode, start quickly, and execute slightly slower
• -Xcomp: Use pure compilation mode, execute very fast, start very slowly

5.Linking

1. It is divided into three steps: verification, preparation, and resolution, see the figure in the overview
2. Give a chestnut, the result is 2

public class Test{
    public static void main(String[] args) {
        System.out.println(T.count);
    }
}

class T {
    public static T t = new T(); //default null
    public static int count = 2; //default 0

    private T() {
        count ++;
    }
}