单例模式之内部类延迟加载，（多）线程安全

妖狐艹你老母 2022-04-04 16:42 201阅读 0赞

单例模式，很多种方式实现，但是这儿只介绍最优方案。

就是利用内部类去实现单例模式。

这种单例模式的好处就是，延迟加载，减少内存开销，访问成本低且线程安全。

直接上代码：

/**
     * @Author : JCccc
     * @CreateTime : 2018-11-5
     * @Description :
     * @Point: Keep a good mood
     **/
    
    public class SingletonInner {
    
    
    
    
    //    静态嵌套类（Static Nested Class）和内部类（Inner Class）的不同
    //    静态嵌套类是被声明为静态（static）的内部类，可以不依赖于外部类被实例化,
    //    内部类需要在外部类实例化后才能实例化.
    
    
        /**
         * 内部类实现单例模式
         * 延迟加载，减少内存开销
         */
    
        /**
         * 在内部类SingletonHolder 第一次被加载的时候，创建了instance，指向SingletonInner的实例。
         */
        private static class SingletonHolder {
            private static SingletonInner instance = new SingletonInner();
        }
    
        /**
         * 私有的构造函数
         */
        private SingletonInner() {
            System.out.println("Singleton is create");
        }
    
        public static SingletonInner getInstance() {
    
            return SingletonHolder.instance;
        }
    
        public void method() {
            System.out.println("SingletonInner!");
        }
    
    
    
        public static void main(String[] args) {
            SingletonInner Single_dog1 = SingletonInner.getInstance();
            SingletonInner Single_dog2 = SingletonInner.getInstance();
            SingletonInner Single_dog3 = SingletonInner.getInstance();
            System.out.println(Single_dog1+"\n"+Single_dog2+"\n"+Single_dog3);
    
    
            
    
    
        }
    }

针对内部类为何能保证线程安全，实现延迟加载，下面是简要的说明：

private static class SingletonHolder \{  
        private static SingletonInner instance = new SingletonInner();  
    \}

这个内部类因为被static修饰，代表，这个货是一个类级别的内部类。  
     如果没有被static修饰，就是一个对象级别的内部类，这种内部类是必须绑定在外部对象实例上的  
     这种类级别内部类的好处是什么，就是虚拟机JVM的内部机制对它是有保护的，只允许它第一次被加载，其余都是互斥的。

虚拟机会保证一个类的类构造器<clinit>()在多线程环境中被正确的加锁、同步，如果多个线程同时去初始化一个类，那么只会     有一个线程去执行这个类的类构造器<clinit>()，其他线程都需要阻塞等待，直到活动线程执行<clinit>()方法完毕。

特别需要注意的是，在这种情形下，其他线程虽然会被阻塞，但如果执行<clinit>()方法的那条线程退出后，其他线程在唤醒之     后不会再次进入/执行<clinit>()方法，因为 在同一个类加载器下，一个类型只会被初始化一次。如果在一个类的<clinit>()方法中     有耗时很长的操作，就可能造成多个线程阻塞，在实际应用中这种阻塞往往是隐藏的。

这里其实是验证小测试，看看运行结果，就懂了吧：

![20181218102721594.png][]

没错，就是单例验证。 也许你debug去调试，你会发现创建了3次对象，实际上都是指向同一个的。

好了，到此。

[20181218102721594.png]: /images/20220404/1b1d0e620c524682b0672ce7ce27e55a.png