类型：创建型
定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
解决的问题：在任何时间内只有一个类实例存在的模式
解决方法：保证一个类只有一个实例化对象，并提供一个全局访问入口
本质：控制实例的数量

方法一：饿汉式单例模式

public class BadmashSingleton {
    // 在类加载的时候即被实例化
    private static BadmashSingleton instance = new BadmashSingleton();
    private BadmashSingleton() {}

    public static BadmashSingleton getInstance() {
        return instance;
    }
}

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。
缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。
性能： 性能比较好

方法二：饿汉式（静态代码块）（线程安全）

public class Singleton {

    private static Singleton instance;

    static {
        instance = new Singleton();
    }

    private Singleton() {}

    public static Singleton getInstance() {
        return instance;
    }
}

方法三：懒汉式单例模式【多线程有问题】

public class IdlerSingleton {
    private static IdlerSingleton instance = null;
    private IdlerSingleton() {
    }
    // 在使用时才进行加载
    public static IdlerSingleton getInstance() {
        if (null == instance) {
            instance = new IdlerSingleton();
        }
        return instance;
    }
}

线程安全性： 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。问题出现在if (null == instance)这一步，多线程环境中可能会有多个线程同时拿到instance的值为null。
是否懒加载： 懒加载
性能： 性能比较好

方法四：懒汉式单例模式+同步方法【性能差，不推荐使用】

public class IdlerSynSingleton {
    private static IdlerSynSingleton instance = null;
    private IdlerSynSingleton() {}

    public static synchronized IdlerSynSingleton getInstance() {
        if (null == instance) {
            instance = new IdlerSynSingleton();
        }
        return instance;
    }
}

线程安全性： 线程安全
是否懒加载： 懒加载
性能： synchronized修饰方法，使得多线程执行退化为串行执行，性能差

方法五：懒汉式单例模式+同步代码块

public class IdlerSynSingleton {
    private static IdlerSynSingleton instance = null;
    private IdlerSynSingleton() {}

    public static IdlerSynSingleton getInstance() {
        if (null == instance) {
            synchronized (IdlerSynSingleton.class) {
                instance = new IdlerSynSingleton();
            }
        }
        return instance;
    }
}

线程安全性： 单线程下没有问题，多线程下有可能会生成多个实例，因此线程不安全。问题同样出现在if (null == instance)这一步
是否懒加载： 懒加载
性能： 性能一般

方法六：DCL单例模式+Volatile【可用】

public class DCLSingleton {
    private static volatile DCLSingleton instance = null;
    private DCLSingleton() {}

    public static DCLSingleton getInstance() {
        if (null == instance) {
            synchronized (DCLSingleton.class) {
                if (null == instance) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

线程安全性： 线程安全性
是否懒加载： 懒加载
性能： 性能比较好

方法七：Holder单例模式

public class HolderSingleton {
    private static HolderSingleton instance = null;
    private HolderSingleton() {}

    public static HolderSingleton getInstance() {
        return Holder.instance;
    }

    private static class Holder {
        private static HolderSingleton instance = new HolderSingleton();
    }
}

线程安全性： 线程安全性
是否懒加载： 懒加载
性能： 性能好

内部类无法被序列化，即使实现了Serializable接口也不可以，内部类(嵌套类)要想能够序列化，除了本身和所有成员属性都要实现序列化接口以外，要么声明为静态嵌套类，要么让外部类也实现序列化接口。

方法八：Enum单例模式【推荐】

public class EnumSingleton {
    private EnumSingleton() {}

    public static EnumSingleton getInstance() {
        return EnumHolder.INSTANCE.getInstance();
    }

    private enum EnumHolder {
        INSTANCE;
        private EnumSingleton instance = null;

        private EnumHolder() {
            instance = new EnumSingleton();
        }

        private EnumSingleton getInstance() {
            return instance;
        }
    }
}

线程安全性： 线程安全性
是否懒加载： 懒加载
性能： 性能好

高并发情况下单例模式的选用标准

1.如果要产生的单例对象占用资源比较少，不需要延时加载，则：枚举式好于饿汉式。
2.如果要产生的单例对象占用资源比较大，需要延时加载，则：静态内部类好于懒汉式。