一、单例模式的概念
单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。这种模式涉及到一个单一的类,该类负责创建自己的对象,同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式,可以直接访问,不需要实例化该类的对象。单例模式的主要作用是保证一个类仅有一个实例,并提供一个访问它的全局访问点,而且自行实例化并向整个系统提供这个实例,同时避免一个全局使用的类频繁地创建与销毁。在计算机系统中,线程池、缓存、日志对象、对话框、打印机、显卡的驱动程序对象常被设计成单例,这些应用都或多或少具有资源管理器的功能,当需要控制实例数目,节省系统资源的时候就可以考虑使用单例。
二、单例模式特点:
- 1、单例类只能有一个实例,通常还要考虑反射破坏、序列化/反序列化、对象垃圾回收等问题。
- 2、单例类必须自己创建自己的唯一实例,通常给实例构造函数protected或private权限。
- 3、单例类必须给所有其他对象提供这一实例,通常定义静态方法getInstance()返回。
单例模式保证了全局对象的唯一性,比如系统启动读取配置文件就需要单例保证配置的一致性。
三、使用场景
- 1、要求生产唯一序列号。
- 2、WEB 中的计数器,不用每次刷新都在数据库里加一次,用单例先缓存起来。
- 3、创建的一个对象需要消耗的资源过多,比如 I/O 与数据库的连接等。
四、线程安全的问题
一方面在获取单例的时候,要保证不能产生多个实例对象,下面会详细讲到五种实现方式;另一方面,在使用单例对象的时候,要注意单例对象内的实例变量是会被多线程共享的,推荐使用无状态的对象,不会因为多个线程的交替调度而破坏自身状态导致线程安全问题,比如我们常用的VO,DTO等(局部变量是在用户栈中的,而且用户栈本身就是线程私有的内存区域,所以不存在线程安全问题)。
五、实现方式
- 1、饿汉式单例(立即加载方式)
// 饿汉式单例
public static class HungrySingleton {
// 私有构造
private HungrySingleton() {}
private static HungrySingleton single = new HungrySingleton();
// 静态工厂方法
public static HungrySingleton getInstance() {
System.out.println("HungrySingleton getInstance...");
return single;
}
}
这种方式比较常用,但容易产生垃圾对象。instance 在类加载初始化时就创建好一个静态的实例对象供外部使用,除非系统重启,这个对象不会改变,它基于 classloader 机制避免了多线程的同步问题,所以是线程安全的,不过这时候初始化 instance 显然没有达到 Lazy loading(延迟加载) 的效果,浪费内存和系统资源。HungrySingleton 通过将构造方法限定为private避免了类在外部被实例化,在同一个虚拟机范围内,Singleton的唯一实例只能通过getInstance()方法访问。(事实上,通过Java反射机制是能够实例化构造方法为private的类的,那基本上会使所有的Java单例实现失效。此问题在此处不做讨论,姑且闭着眼就认为反射机制不存在。)
- 2、懒汉式单例(延迟加载方式)
//懒汉式单例 -- 非线程安全
public static class LazySingleton {
// 私有构造
private LazySingleton() { }
private static LazySingleton single;
public static LazySingleton getInstance() {
if (single == null) {
single = new LazySingleton();
}
System.out.println("LazySingleton getInstance...");
return single;
}
}
这种方式 Lazy loading 很明显,最大的问题就是不支持多线程,线程环境下会产生多个single对象,可以使用synchronized同步锁改造:
//懒汉式单例-线程安全
public static class LazySyncSingleton {
// 私有构造
private LazySyncSingleton() { }
private static LazySyncSingleton single;
public static synchronized LazySyncSingleton getInstance() {
if (single == null) {
single = new LazySyncSingleton();
}
System.out.println("LazySyncSingleton getInstance...");
return single;
}
}
在方法上加synchronized同步锁或是用同步代码块对类加同步锁,此种方式虽然解决了多个实例对象问题,但是该方式运行效率却很低下,下一个线程想要获取对象,就必须等待上一个线程释放锁之后,才可以继续运行。可以使用双重检查锁(DCL,即 double-checked locking)进一步优化:
//懒汉式-DCL双重校验锁,高效线程安全
public static class LazyDclSingleton {
private volatile static LazyDclSingleton singleton;
private LazyDclSingleton() {
}
public static LazyDclSingleton getInstance() {
if (singleton == null) {
synchronized (LazyDclSingleton.class) {
if (singleton == null) {
singleton = new LazyDclSingleton();
}
}
}
System.out.println("LazyDclSingleton getInstance...");
return singleton;
}
}
这种方式可以避免整个方法被锁,只对需要锁的代码部分加锁,getInstance() 的性能对应用程序很关键,可以提高执行效率!
懒汉式与饿汉式的根本区别在与是否在类内方法外创建自己的对象。并且声明对象都需要私有化,构造方法都要私有化,这样外部才不能通过 new 对象的方式来访问。饿汉式的话是声明并创建对象(因为他饿),懒汉式的话只是声明对象,在调用该类的 getinstance() 方法时才会进行 new 对象。
- 3、静态内部类实现-登记式
// 静态内部类实现单例-登记式
public static class RegisterSingleton{
// 私有构造
private RegisterSingleton() {
}
/**
* 静态内部类
* <p>
* 这种方式同样利用了 classloader 机制来保证初始化 instance 时只有一个线程,
* Singleton 类被装载了,instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用,
* 只有通过显式调用 getInstance 方法时,才会显式装载 SingletonHolder 类,从而实例化 instance
*/
private static class SingletonHolder {
private static final RegisterSingleton INSTANCE = new RegisterSingleton();
}
public static RegisterSingleton getInstance() {
System.out.println("RegisterSingletongetInstance");
return SingletonHolder.INSTANCE;
}
}
这种方式能达到双检锁方式一样的功效,但实现更简单。对静态域使用延迟初始化,应使用这种方式而不是双检锁方式。这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。静态内部类虽然保证了单例在多线程并发下的线程安全性,但是在遇到序列化对象时,默认的方式运行得到的结果就是多例的。这种情况不多做说明了,使用时请注意。
- 4、static静态代码块实现
//静态代码块实现单例
public static class StaticBlockSingleton {
// 私有构造
private StaticBlockSingleton() {
}
private static StaticBlockSingleton single = null;
// 静态代码块
static {
single = new StaticBlockSingleton();
}
public static StaticBlockSingleton getInstance() {
return single;
}
}
- 5、枚举类实现
//Effective Java 作者 Josh Bloch 提倡
public enum EnumSingleton {
INSTANCE;
public void showMessage() {
System.out.println("Hello EnumSingleton");
}
}
这是实现单例模式的最佳方法。它更简洁,自动支持序列化机制,绝对防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式,它不仅能避免多线程同步问题,而且还自动支持序列化机制,防止反序列化重新创建新的对象,绝对防止多次实例化。不过,由于 JDK1.5 之后才加入 enum 特性,用这种方式写不免让人感觉生疏,在实际工作中,也很少用。不能通过 reflection attack 来调用私有构造方法。
经验之谈:一般情况下,不建议使用LazySingleton 和LazySyncSingleton懒汉方式,建议使用HungrySingleton饿汉方式。只有在要明确实现 Lazy loading 效果时,才会使用RegisterSingleton静态内部类方式。如果涉及到反序列化创建对象时,可以尝试使用EnumSingleton枚举方式。如果有其他特殊的需求,可以考虑使用LazyDclSingleton 双检锁方式。
备注:本文单例实现部分,实例源码参照《Java多线程编程核心技术》-(高洪岩)一书中第六章的学习案例撰写。
获取文章中完整代码示例可访问github:https://github.com/grayee/ecms/tree/master/ecms-web/src/test