设计模式之单例模式
简介
单例模式,是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中,使用单例模式的类只有一个对象实例。
单例应用场景
1、Windows系统的任务管理器。
2、Windows系统的回收站。
3、操作系统的文件系统,一个操作系统只能有一个文件系统。
4、数据库连接池的设计与实现。
5、多线程的线程池设计与实现。
6、Spring中创建的Bean实例默认都是单例。
7、Java-Web中,一个Servlet类只有一个实例。
8、等等…
单例的优缺点
优点
一、实例控制
单例模式会阻止其他对象实例化其自己的单例对象的副本,从而确保所有对象都访问唯一实例。
二、灵活性
因为类控制了实例化过程,所以类可以灵活更改实例化过程。
缺点
一、开销
虽然数量很少,但如果每次对象请求引用时都要检查是否存在类的实例,将仍然需要一些开销。可以通过使用静态初始化解决此问题。
二、可能的开发混淆
使用单例对象(尤其在类库中定义的对象)时,开发人员必须记住自己不能使用new关键字实例化对象。因为可能无法访问库源代码,因此应用程序开发人员可能会意外发现自己无法直接实例化此类。
三、对象生存期
不能解决删除单个对象的问题。在提供内存管理的语言中(例如基于.NET Framework的语言),只有单例类能够导致实例被取消分配,因为它包含对该实例的私有引用。在某些语言中(如 C++),其他类可以删除对象实例,但这样会导致单例类中出现悬浮引用。。
实现单例的几种方式
一、饿汉式
* 1、构造器私有化
* 2、自行创建,并且静态变量保存
* 3、向外提供这个实例
* 4、强调这是一个单例可以,直接使用final
public class Singleton1 {
public static final Singleton1 INSTANCE=new Singleton1();
private Singleton1() {
}
}
public class test {
public static void main(String[] args) {
Singleton1 s=Singleton1.INSTANCE;
Singleton1 s2=Singleton1.INSTANCE;
System.out.println(s==s2);
}
}
总结:线程安全、非懒加载、效率高。
是否推荐:可以使用,但不推荐。
二、懒汉式
/**
* 懒汉式:
* 延迟加载这个实例对象
*
* 1、构造器私有
* 2、用一个静态变量保存这个唯一的实例
* 3、提供一个静态方法,获取这个实例对象
*/
public class Singleton2 {
private static Singleton2 instance;
private Singleton2() {
}
public static Singleton2 getInstance() {
if (instance == null) {
instance = new Singleton2();
}
return instance;
}
}
总结:线程安全、懒加载、效率低。
是否推荐:可以使用,但不推荐。
注:该模式还有另一种常见写法,就是把getInstance方法上的synchronized去掉,这种方法有线程安全问题,不能使用。
三、.双重检测机制(DCL)
public class singleton{
private static volatile Singleton singleton;
private Singleton(){}
public static Singleton getInstance(){
if(singleton == null){
synchronized(Singleton.class ) {
if(singleton == null){
singleton =new Singleton();
}
}
}
return singleton;
}
}
双重检测机制(双重检查加锁),比较常见的一种写法。在第一次使用的时候才进行初始化,达到了懒加载的效果;在进行初始化的时候会进行同步(加锁),因此没有线程安全问题;并且只有第一次进行初始化才进行同步,因此不会有效率方面的问题。
《Java Concurrency in Practice》作者Brian Goetz在书中提到关于DCL的观点:促使DCL模式出现的驱动力(无竞争同步的执行速度很慢,以及JVM启动时很慢)已经不复存在,因而它不是一种高效的优化措施。延迟初始化占位类模式(静态内部类)能带来同样的优势,并且更容易理解。
总结:线程安全、懒加载、效率高。
是否推荐:可以使用。
注:该模式还有另一种常见写法,就是把静态实例singleton的volatile修饰去掉,这种方法有线程安全方面的问题,不能使用。请见下面这个例子。
双重检测机制实现单例(没有volatile修饰)
public class singleton{
//没有volatile修饰实例
private static Singleton instance;
//私有构造
private Singleton(){}
public static Singleton getInstance(){ //对外提供的工厂方法
if(singleton == null){ //第一次检测
synchronized(Singleton.class ) { //同步锁
if(singleton == null){ //第二次检测
singleton =new Singleton(); //初始化
}
}
}
return singleton;
}
这个地方有可能会参数线程不安全的情况 ,如果是多线程,线程A到了第二次检测 ,线程B到了第一次检测,但是线程A还没有初始化,线程B指向的不再是null,那么这个时候就会产生两个实例!那么如何解决这个问题 就是上面那种方法 用volatile修饰instance
静态内部类(延迟初始化占位类)
public class Singleton{
private static class Inner{
private static final Singleton INSTANCE = new Singleton();
}
private Singleton() {}
public static Singleton getInstance(){
return Inner.INSTANCE
}
}
在内部类被加载和初始化时,才创建INSTANCE实例对象
静态内部类不会自动随着外部类的加载和初始化而初始化,它是单独去加载和初始化的
因为实在内部类加载和初始化时,创建的,因此是线程安全的
总结:线程安全、懒加载、效率高。
是否推荐:推荐使用、《Java Concurrency in Practice》作者Brian Goetz推荐使用的方式
枚举
public enum Singleton2 {
INSTANCE
}
枚举,不是很常见的一种写法。很简洁的一种实现方式,提供了序列化机制,保证线程安全,绝对防止多次实例化,即使是在面对复杂的序列化或者反射攻击的时候。
总结:线程安全、非懒加载、效率高。
是否推荐:推荐使用、《Effective Java》作者Joshua Bloch推荐使用的方式。
几种方式对比:
方式 | 优点 | 缺点 |
---|---|---|
饿汉 | 线程安全、效率高 | 非懒加载 |
懒汉 | 线程安全、懒加载 | 效率低 |
双重检测 | 线程安全、效率高、懒加载 | 无 |
静态内部类 | 线程安全、效率高、懒加载 | 无 |
枚举 | 线程安全、效率高 | 非懒加载 |
可能有人看了以上表格,觉得枚举有缺点,为什么Joshua Bloch还推荐使用枚举?
这就要提到单例的破解了。普通的单例模式是可以通过反射和序列化/反序列化来破解的,而Enum由于自身的特性问题,是无法破解的。当然,由于这种情况基本不会出现,因此我们在使用单例模式的时候也比较少考虑这个问题。
总结:
- 单例无论是在项目的开发中,还是面试中都是非常常见的,因此需要熟练的掌握好单例的知识。只要记住单例的三个实现要点——私有构造方法、定义静态Singleton实例、暴露实例获取方法,手写这5种实现方式相信都是信手拈来。如果是面试的时候,建议使用静态内部类的实现。
- 项目中具体使用哪种实现方式可以根据情况而定,个人推荐的方式是:静态内部类和枚举,我自己在项目中常见的也是这两种方式,可能静态内部类会更多一点。另外就是毕竟是两位大神推荐的,还考虑什么,直接用就是了。