介绍
这种模式只涉及到一个单一的类,该类负责创建自己的对象,并确保只创建一个对象。
单例只有一个实例;
单例类必须创建自己唯一的实例;
单例类必须给其他对象提供这唯一的实例;
分类
由于当今的编程模型都是基于多线程方式,因此此处只介绍线程安全的几种实现。
懒汉型
第一次被调用时才创建对象,属于懒加载(Lazy-Init), 节约一定的内存,但由于需要增加同步锁,因此性能会低一些。
public class LazySingleton {
private static LazySingleton lazySingleton;
public static synchronized LazySingleton getInstance() {
if (lazySingleton == null) {
lazySingleton = new LazySingleton();
}
return lazySingleton;
}
}
饿汉型
类加载时就创建对象,不属于懒加载(Lazy-Init),因此会有一定的内存损耗,但不适用同步锁,因此性能会高一些。
public class HungrySingleton {
private static HungrySingleton hungrySingleton = new HungrySingleton();
public static HungrySingleton getInstance() {
return hungrySingleton;
}
}
双重锁型
采用双重锁的机制,属于懒加载(Lazy-Init),既能保证线程安全,也不过多损失性能。
public class DubbleLockSingleton {
private static volatile DubbleLockSingleton dubbleLockSingleton;
public static DubbleLockSingleton getInstance() {
if (dubbleLockSingleton == null) {
synchronized (DubbleLockSingleton.class) {
if (dubbleLockSingleton == null) {
dubbleLockSingleton = new DubbleLockSingleton();
}
}
}
return dubbleLockSingleton;
}
}
静态内部类型
比双重锁实现简单,比饿汉型更节省资源,因为是内部类被调用时才创建对象。
public class StaticInternalSingleton {
private static class StaticInternalSingletonHolder {
private static StaticInternalSingleton INSTANCE = new StaticInternalSingleton();
}
public static StaticInternalSingleton getInstance() {
return StaticInternalSingletonHolder.INSTANCE;
}
}