单例,顾名思义,就是单个实例,也就是说,某个类如果实现了单例模式,那这个类就只能生成一个实例。
在一些应用中,可能会有一些工具类,这些类为其他类服务,本身没有太多数据要保存。如果使用这样的类的时候,每次都用new创建一个对象的话,会增加系统的开销。在实际设计时,这种只需要一个实例对象的类就应该设计为单例模式。
另外,比如:线程池、缓存、网络请求等。当这类对象有多个实例时,程序就可能会出现异常,比如:程序出现异常行为、得到的结果不一致等,这时候也应该使用单例模式。
关键点:
几种常见单例模式的实现方式
在类加载的期间,就已经将 instance 静态实例初始化好了,所以,instance 实例的创建是线程安全的。不过,这样的实现方式不支持延迟加载实例。
public class Singleton {
// 静态字段引用唯一实例:
private static final Singleton INSTANCE = new Singleton();
// 通过静态方法返回实例:
public static Singleton getInstance() {
return INSTANCE;
}
// private构造方法保证外部无法实例化:
private Singleton() {
}
}
或者 直接把 static变量暴露给外部:
public class Singleton {
// 静态字段引用唯一实例:
public static final Singleton INSTANCE = new Singleton();
// private构造方法保证外部无法实例化:
private Singleton() {
}
}
懒汉式相对于饿汉式的优势是支持延迟加载。但它的缺点也很明显,getInstance 使用了 synchronize 实现线程同步,导致这个方法的并发很低,每次调用都会频繁的枷锁、释放锁,会导致性能瓶颈。
public class Singleton {
private Singleton(){}
private static Singleton instance;
public static synchronized Singleton getInstance(){
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
饿汉式不能延时加载,懒汉式有性能问题,而双重检测方式既支持延迟加载、又支持高并发的单例实现方式。
当 instance 对象被创建后,再次调用 getInstance 方法不再会进入 synchronize 加锁的代码之中。
它的优点是:资源利用率高,第一次执行 getInstance 时才会被实例化,效率高。缺点是:第一次加载反应稍慢。
public class Singleton {
private Singleton(){}
private static Singleton instance;
public static Singleton getInstance(){
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
有时候,面试官会问这种实现方式有什么问题。他们指的就是指令重排序。
instance = new Singleton(); 并不是一个原子操作, 这句代码实际执行了三件事。
1、 给 Singleton 的实例分配内存;
2、调用 Singleton 的构造函数,初始化成员变量;
3、将 instance 的对象指向分配的内存空间。
因为 Java 编译器允许处理器乱序执行,2、3的顺序是无法保证的。如果是 1-3-2 执行的顺序,当执行完 3 、2未执行之前,被切换到 B 线程,此时 instance 已经非空,B 会直接取走 instance,在使用时就会出错。
这就是指令重排。
解决办法也很简单:只需要给 instance 成员变量加上 volatile 关键字,就可以禁止指令重排序。
其实这个问题在高版本的 java 中已经被解决了,解决方式也很简单,就是把对象 new 操作和初始化操作设计为原子操作,就自然能禁止重排序。
使用 Java 的静态内部类也能够实现。
public class Singleton {
private Singleton(){}
private static class Instance {
private static final Singleton instance = new Singleton();
}
public static Singleton getInstance(){
return Instance.instance;
}
}
当第一次加载 Singleton 类时并不会初始化 instance,只有在第一次调用 Singleton 的 getInstance 方法时才会导致 instance 被初始化。
第一次调用 getInstance 方法时会导致虚拟机加载 Instance 类,这种方式不仅能保证线程安全,也能够保证单例对象唯一,同时也延迟了单例的实例化。
另一种实现Singleton的方式是利用Java的enum,因为Java保证枚举类的每个枚举都是单例,所以我们只需要编写一个只有一个枚举的类即可:
public enum World {
// 唯一枚举:
INSTANCE;
private String name = "world";
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
}
枚举类也完全可以像其他类那样定义自己的字段、方法,这样上面这个World类在调用方看来就可以这么用:
String name = World.INSTANCE.getName();
使用枚举实现Singleton还避免了第一种方式实现Singleton的一个潜在问题:即序列化和反序列化会绕过普通类的private构造方法从而创建出多个实例,而枚举类就没有这个问题。
那我们什么时候应该用Singleton呢?实际上,很多程序,尤其是Web程序,大部分服务类都应该被视作Singleton,如果全部按Singleton的写法写,会非常麻烦,所以,通常是通过约定让框架(例如Spring)来实例化这些类,保证只有一个实例,调用方自觉通过框架获取实例而不是new操作符:
@Component // 表示一个单例组件
public class MyService {
...
}