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

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

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方法并没有被同步，并且只是执行一个域的访问，因此延迟初始化并没有增加任何访问成本。