1、定义
单例模式(Singleton Pattern):确保某一个类只有一个实例,自行实例化并向整个系统提供这个实例。
2、形式
单例模式分为懒汉式和饿汉式两种,形式如下所述。
饿汉式
通用类图和代码如下所示:
public class Singleton {
private static final Singleton singleton = new Singleton();
private Singleton(){}
public static Singleton getSingleton(){
return singleton;
}
public static void doSomething(){
/**
* 其他业务代码
*/
}
}
饿汉式单例模式是线程安全的,通过将单例对象用static
修饰,把实例对象加载到堆中,保证了多个线程访问时的可见性。但该方式的缺点在于应用一加载该实例就会进入堆中,可能会浪费内存。
懒汉式
懒汉式是当应用需要时才加载实例对象,代码如下所示:
public class Singleton {
private static Singleton singleton = null;
private Singleton(){}
public static Singleton getSingleton(){
if(singleton == null){
singleton = new Singleton();
}
return singleton;
}
public static void doSomething(){
/**
* 其他业务代码
*/
}
}
这种方式虽然性能很好,但带来的显著问题是高并发情况下的线程安全问题。如果一个线程还未产生实例对象,其他线程正好执行到if(singleton == null)
的逻辑判断,那么会造成内存中出现多个实例对象!
一个解决线程安全的办法是在getSingleton()
方法前加上synchronized
关键字,这表明同一时间内只允许一个线程访问,保证了线程安全,但在高并发情况下其他线程必须等待当前线程释放方法锁,极大的影响了系统性能,因此不建议使用。
那么进一步优化,减少锁的粒度,让它在实例的产生处进行并发控制如何?代码如下所示:
public class Singleton {
private static Singleton singleton = null;
private Singleton(){}
public static Singleton getSingleton(){
if(singleton == null){
synchronized (Singleton.class){
singleton = new Singleton();
}
}
return singleton;
}
public static void doSomething(){
/**
* 其他业务代码
*/
}
}
很显然这依然会出现线程安全问题,假如一个线程A执行完判断if(singleton == null)
后被另一个线程B抢占执行,等B执行完生成实例后,A线程获得执行权依然会生成一个新实例。
再次改进,得到双重检测同步锁机制,代码如下:
public class Singleton {
private static Singleton singleton = null;
private Singleton(){}
public static Singleton getSingleton(){
if(singleton == null){
synchronized (Singleton.class){
if(singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
public static void doSomething(){
/**
* 其他业务代码
*/
}
}
虽然这种方式看起来十分安全,但很不幸,该机制依然无法保证线程安全,这是由于编译器(JVM)优化中的指令重排机制导致的,详见另一篇博文volatile概念详解及使用场景。
volatile+双重检测机制实现懒汉式单例
public class Singleton {
private volatile static Singleton singleton = null;
private Singleton(){}
public static Singleton getSingleton(){
if(singleton == null){
synchronized (Singleton.class){
if(singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
public static void doSomething(){
/**
* 其他业务代码
*/
}
}
由于volatile
的禁止指令重排能力,保证了该单例模式下的线程安全。
枚举类实现懒汉式单例
由于上面的双重检测机制利用了volatile
关键字,如果单例模式中存在其他的涉及线程安全问题(例如不是指令重排导致的),或volatile
没能有效在JVM中实现(例如在JavaSE5之前),那么上述方式也无法保证线程的安全。一个最为推荐的方式是使用枚举类实现懒汉式单例,由于JVM保证枚举类中的调用方法只调用一次,因此有效的保证类只实例化一次。实现代码如下:
public class SingletonCase {
private SingletonCase(){}
public static SingletonCase getSingleton(){
return Singleton.INSTANCE.getInstance();
}
private enum Singleton{
INSTANCE;
private SingletonCase singleton;
Singleton(){
singleton = new SingletonCase();
}
public SingletonCase getInstance(){
return singleton;
}
}
public static void doSomething(){
/**
* 其他业务代码
*/
}
}
3、优缺点
优点:
- 由于内存中只有一个实例,故而减少了内存开支
- 当一个对象需要产生比较多的资源(如读取配置、产生其他依赖对象等)时,使用单例模式可以减少系统的性能开销
- 单例模式可以避免对资源的多重占用,例如对于写文件动作,由于只有一个实例在内存中,避免了对同一个资源同时进行写操作
- 单例模式可以在系统设置全局的访问点,优化和共享资源的访问,例如设计一个单例类负责所有数据表的映射处理
缺点:
- 单例模式一般没有接口,难以扩展
- 单例模式对测试不友好,在并行开发的环境下,如果单例模式没有完成,无法进行测试
- 单例模式跟单一职责原则有冲突
注:一个类应该只实现一个逻辑,而不应该关心其是否是单例的,单例与否取决于环境,好的单例模式应当把单例和业务逻辑融合在一个类中。
4、使用场景
- 生成唯一序列号的环境
- 在整个项目中需要一个共享访问点或共享数据,例如Web上的计数器,通过一个单例模式保存计数器的值,并确保是线程安全的。
- 创建一个对象需要消耗的资源过多,比如访问IO或数据库
- 定义大量静态常量和静态方法的环境,例如工具类
注:工具类也可以采用静态类(所有的方法都是静态方法)实现。一般来说,如果是存在配置信息的工具类,一般适合采用单例模式;而如果只是无配置信息的简单工具类,更适合直接采用静态类的方式实现。
5、扩展
多例模式
public class Singletons {
//最大单例数
private static int maxNumOfSingleton = 2;
private Singletons(){}
//单例集合
private static ArrayList<Singletons> singletonsList = new ArrayList<Singletons>();
//生成实例对象
static {
for (int i = 0; i < maxNumOfSingleton; i++) {
singletonsList.add(new Singletons());
}
}
public static Singletons getInstance(){
Random random = new Random();
int i = random.nextInt(maxNumOfSingleton);
return singletonsList.get(i);
}
public static void doSomething(){
/**
* 其他业务代码
*/
}
}
这种产生固定数量对象的模式可以决定在内存中有多少个实例,方便系统进行扩展,以修正单例可能存在的性能问题。例如读取文件,可以通过生成固定数量的reader
实例来满足多请求下的快速响应。
6、小结
单例模式是23个模式中较为简单的模式,在Spring中,每个Bean默认就是单例的,这样做的优点是Spring容器可以管理这些Bean的声明周期。如果采用非单例模式(Prototype类型),则Bean初始化后的管理交由J2EE容器。