懒加载模式的单例          返回主页

说到单例模式，想必各位小伙伴都能够不假思索的挥手写一段出来。并且能对其分类有所理解。

传统的单例模式---懒汉模式

    public class Singleton{

        private static final Singleton singleton = null;

        private Sinleton(){}

        public Singleton getSingletonInstance() {
            if(singleton == null) {
                singleton = new Sinleton();
            }
            return sinleton;
        }

        public static void otherMethod(){}
    }

传统的单例模式---饿汉模式

    public class Singleton{

        private static final Singleton singleton = new Sinleton();

        private Sinleton(){}

        public Singleton getSingletonInstance() {
            return sinleton;
        }

        public static void otherMethod(){}
    }

这里要指出的是，单例模式的应用场景：一般对只需要加载一次的对象使用单例模式进行加载，有时候为了调用单例类中的某个方法不需要对整个单例进行类加载，而且上述的懒汉模式存在线程不安全问题，为了避免上述的问题，我们引入静态内部类进行解决，完成单例的懒加载(延迟加载)。

    类级内部类相当于其外部类的static成员，它的对象与外部类对象间不存在依赖关系，
    相互独立，因此可直接创建。而对象级内部类的实例，是必须绑定在外部对象实例上的。
    类级内部类只有在第一次被使用的时候才被会装载。

    要想很简单地实现线程安全，可以采用静态初始化器的方式，它可以由JVM来保证线程的安全性，
    如饿汉式单例，这种实现方式，会在类装载的时候就初始化对象，有可能浪费一定的内存（假设你不需要的话），
    有一种方法能够让类装载的时候不去初始化对象，就是采用类级内部类，在这个类级内部类里面去创建对象实例。

代码实现

    public class Singleton {

        private Singleton() {
            System.out.println("单例创建成功");
        }

        private static class InnerSingleton {
            private static final Singleton singletonInstance = new Singleton();
        }

        public static Singleton getSingletonInstance() {
            return InnerSingleton.singletonInstance;
        }

        public static void otherMethod() {
            System.out.println("其他方法执行");
        }

        public static void main(String[] args) {
            Singleton.otherMethod();
        }
    }

小结

当getSingletonInstance方法第一次被调用的时候，它第一次读取InnerSingleton.singletonInstance，内部类InnerSingleton类得到初始化；

而这个类在装载并被初始化的时候，会初始化它的静态域，从而创建singletonInstance的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性。

这个模式的优势在于，getSingletonInstance方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。