静态内部类实现单例模式以及不需要显式使用锁的原因

先说结论：

静态内部类实现单例模式，是借助了类加载器加载类的特性实现的，类加载器在加载类时使用了synchronized关键字．

单例模式代码：

public class SingletonDemo {

    public static void main(String[] args) {
        SingletonDemo sd1 = getInstance();
        SingletonDemo sd2 = getInstance();
        System.out.println(sd1.equals(sd2));       
    }

    private SingletonDemo(){};

    private static class SingletonHolder{
        private static SingletonDemo INSTANCE = new SingletonDemo();

    }
    
    public static SingletonDemo getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

输出为：

true

首次执行getInstance()方法，调用SingletonHolder中的静态属性INSTANCE时，触发SingletonHolder类的加载，而new SingletonDemo()也会被执行，且只被执行一次．

在多线程环境下是如何实现同步的呢？这就要看ClassLoader类的源码了：

    public Class<?> loadClass(String name) throws ClassNotFoundException {
        return loadClass(name, false);
    }

经过调试，可以确定的是，程序先进入了上面这个方法．但是点击F7进入的却不是下面这个方法：

 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
                    PerfCounter.getParentDelegationTime().addTime(t1 - t0);
                    PerfCounter.getFindClassTime().addElapsedTimeFrom(t1);
                    PerfCounter.getFindClasses().increment();
                }
            }
            if (resolve) {
                resolveClass(c);
            }
            return c;
        }
    }

进入的是ClassLoaders.AppClassLoader类中的loadClass()方法：

        @Override
        protected Class<?> loadClass(String cn, boolean resolve)
            throws ClassNotFoundException
        {
            // for compatibility reasons, say where restricted package list has
            // been updated to list API packages in the unnamed module.
            SecurityManager sm = System.getSecurityManager();
            if (sm != null) {
                int i = cn.lastIndexOf('.');
                if (i != -1) {
                    sm.checkPackageAccess(cn.substring(0, i));
                }
            }

            return super.loadClass(cn, resolve);
        }

执行super.loadClass(),进入了BuiltinClassLoader类中的loadClass()方法：

    @Override
    protected Class<?> loadClass(String cn, boolean resolve)
        throws ClassNotFoundException
    {
        Class<?> c = loadClassOrNull(cn, resolve);
        if (c == null)
            throw new ClassNotFoundException(cn);
        return c;
    }

执行loadClassOrNull()方法，然后进入同一个类中的loadClassOrNull()方法：

 protected Class<?> loadClassOrNull(String cn, boolean resolve) {
        synchronized (getClassLoadingLock(cn)) {
            // check if already loaded
            Class<?> c = findLoadedClass(cn);

            if (c == null) {

                // find the candidate module for this class
                LoadedModule loadedModule = findLoadedModule(cn);
                if (loadedModule != null) {

                    // package is in a module
                    BuiltinClassLoader loader = loadedModule.loader();
                    if (loader == this) {
                        if (VM.isModuleSystemInited()) {
                            c = findClassInModuleOrNull(loadedModule, cn);
                        }
                    } else {
                        // delegate to the other loader
                        c = loader.loadClassOrNull(cn);
                    }

                } else {

                    // check parent
                    if (parent != null) {
                        c = parent.loadClassOrNull(cn);
                    }

                    // check class path
                    if (c == null && hasClassPath() && VM.isModuleSystemInited()) {
                        c = findClassOnClassPathOrNull(cn);
                    }
                }

            }

            if (resolve && c != null)
                resolveClass(c);

            return c;
        }
    }

终于出现了，synchronized关键字！

调用链很长，但是都是在synchronized中了，就不继续往下走了．