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

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

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

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

直接上代码：

/**
 * @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>()方法中     有耗时很长的操作，就可能造成多个线程阻塞，在实际应用中这种阻塞往往是隐藏的。

 

 

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

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

好了，到此。