类型：创建型
定义：保证一个类仅有一个实例，并提供一个访问它的全局访问点。
解决的问题：在任何时间内只有一个类实例存在的模式
解决方法：保证一个类只有一个实例化对象，并提供一个全局访问入口
本质：控制实例的数量
方法一：饿汉式单例模式
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.如果要产生的单例对象占用资源比较大，需要延时加载，则：静态内部类好于懒汉式。
