Classloader类的缓存机制

当我们用ClassLoader去加载类的时候，我们会看到它的loadclass方法，如下：

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;
        }
    }

它有一个方法如下：

Class<?> c = findLoadedClass(name);
protected final Class<?> findLoadedClass(String name) {
        if (!checkName(name))
            return null;
        return findLoadedClass0(name);
    }

    private native final Class<?> findLoadedClass0(String name);

我们发现这是一个native方法，它在jvm底层，做了缓存，缓存的方法在哪里呢，如下：

private Class<?> findBootstrapClassOrNull(String name)
    {
        if (!checkName(name)) return null;

        return findBootstrapClass(name);
    }

    // return null if not found
    private native Class<?> findBootstrapClass(String name);

这个findBootstrapClass方法是个native的方法，它是去获取BootStrapClassLoader里面加载的类是否有这个类，有的话，说明这个类已经被bootStrapClass加载了，
没有的话，用自己的findclass方法加载，findclass是要被子类实现的，以UrlClassLoader子类的findclass方法为例，里面会有defineClass(name, res);方法，
defineClass方法里面会调用如下方法：

private native Class<?> defineClass2(String name, java.nio.ByteBuffer b,
                                         int off, int len, ProtectionDomain pd,
                                         String source);

这个是个native方法，用来加载类，加载的类会缓存到jvm中，通过上面的findLoadedClass方法我们就可以获取到这个类是否被加载过。同时我们在tomcat中加载类的时候，
用到了一个WebappClassLoader，它重写了ClassLoader的loadClass方法，它也做了缓存处理，如如下：

 @Override
    public Class<?> loadClass(String name, boolean resolve) throws ClassNotFoundException {

        synchronized (getClassLoadingLock(name)) {
            if (log.isDebugEnabled())
                log.debug("loadClass(" + name + ", " + resolve + ")");
            Class<?> clazz = null;

            // Log access to stopped class loader
            checkStateForClassLoading(name);

            // (0) Check our previously loaded local class cache
            
protected Class<?> findLoadedClass0(String name) {

        String path = binaryNameToPath(name, true);

        ResourceEntry entry = resourceEntries.get(path);
        if (entry != null) {
            return entry.loadedClass;
        }
        return null;
    }

它把缓存的类放到了一个resourceEntries变量中，这个变量是个map，可以是class类的全限定名，value是一个存放class的类。这个class类是在WebappClassLoaderBase的
findclass方法中的findclassInternal中put进去的。
Spring中也定义了类加载器：ContextClassLoader，其中的原理与此类似。