系统中的某些类,只有一个实例很重要。例如:
如何保证一个类只有一个实例,且该实例易于访问? 定义一个全局变量可以确保对象随时都可以被访问,但无法避免实例化多个对象。
更好的解决办法是让类自身负责保存它的唯一实例。这个类可以保证没有其他实例被创建,并且它可以提供一个访问该实例的方法。这就是单例模式的产生动机。
单例模式确保某个类只有一个实例,而且自行实例化并向整个系统提供这个实例,这个类称为单例类,它提供全局访问的方法。
单例模式的关键如下:
单例模式是一种对象创建型模式。
getInstance() 方法需要使用同步锁 synchronized (Singleton.class) 防止多线程同时进入造成 instance 被多次实例化。
单例模式的目的是保证一个类仅有一个实例,并提供一个访问它的全局访问点。
单例类拥有一个私有构造函数,确保用户无法通过new关键字直接实例化。
在单例模式的实现过程中,需要注意:
一个具有自动编号主键的表可以有多个用户同时使用,但数据库中只能有一个地方分配下一个主键编号,否则会出现主键重复,因此该主键编号生成器必须具备唯一性,可以通过单例模式来实现。 #总结
最基本的实现方式 不支持多线程。因为没有加锁 synchronized,所以严格意义上并不算单例模式 这种方式 lazy loading 很明显,不要求线程安全,当有多个线程并行调用 getInstance() 的时候,就会创建多个实例。也就是说在多线程下不能正常工作。
public class Singleton {
private static Singleton instance;
private Singleton (){}
public static Singleton getInstance() {
if (instance == null) {
instance = new Singleton();
}
return instance;
}
}
为了解决上面的问题,最简单的方法是将整个 getInstance() 方法设为同步(synchronized) 优点:第一次调用才初始化,避免内存浪费。 缺点:必须加锁 synchronized 才能保证单例,但加锁会影响效率。
虽然做到了线程安全,并解决了多实例的问题,但并不高效。 因为在任何时候只能有一个线程调用 getInstance() 但是同步操作只需要在第一次调用时才被需要,即第一次创建单例实例对象时。 这就引出了双重检验锁。
public class Singleton {
private static volatile Singleton INSTANCE = null;
// Private constructor suppresses
// default public constructor
private Singleton() {}
//thread safe and performance promote
public static Singleton getInstance() {
if(INSTANCE == null){
synchronized(Singleton.class){
//when more than two threads run into the first null check same time, to avoid instanced more than one time, it needs to be checked again.
if(INSTANCE == null){
INSTANCE = new Singleton();
}
}
}
return INSTANCE;
}
}
较常用,但易产生垃圾对象
非常简单,实例被声明成 static
和 final
变量了,在第一次加载类到内存中时就会初始化,所以创建实例本身是线程安全的。
它基于类加载机制避免了多线程的同步问题
不过,instance
在类装载时就实例化,虽然导致类装载的原因有很多种,在单例模式中大多数都是调用 getInstance
, 但也不能确定有其他的方式(或者其他的静态方法)导致类装载,这时候初始化instance
显然没有达到lazy loading
public class Singleton {
private final static Singleton INSTANCE = new Singleton();
// Private constructor suppresses
private Singleton() {}
// default public constructor
public static Singleton getInstance() {
return INSTANCE;
}
}
这种写法如果完美的话,就没必要在啰嗦那么多双检锁的问题了。 缺点是它不是一种懒加载模式(lazy initialization),单例会在加载类后一开始就被初始化,即使客户端没有调用 getInstance()方法。 饿汉式的创建方式在一些场景中将无法使用:譬如 Singleton 实例的创建是依赖参数或者配置文件的,在 getInstance() 之前必须调用某个方法设置参数给它,那样这种单例写法就无法使用了。
一种使用同步块加锁的方法。程序员称其为双重检查锁,因为会有两次检查instance == null
:
public class Singleton {
private volatile static Singleton singleton;
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) { // Single Checked
synchronized (Singleton.class) {
if (singleton == null) { // Double Checked
singleton = new Singleton();
}
}
}
return singleton;
}
}
看起来很完美,很可惜哦,它还是有问题。
主要在于
instance = new Singleton()
并非一个原子操作,事实上在 JVM 中这句话大概做了下面 3 件事情
instance = memory
设置instance指向刚分配的内存执行完这步 instance 就为非 null 了)JVM和CPU优化,发生了指令重排 但是在 JVM 的JIT 中存在指令重排序的优化。 也就是说上面的第2步和第3步的顺序是不能保证的,最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者
只需要将 instance 变量声明成volatile
public class Singleton {
private volatile static Singleton instance; //声明成 volatile
private Singleton (){}
public static Singleton getSingleton() {
if (instance == null) {
synchronized (Singleton.class) {
if (instance == null) {
instance = new Singleton();
}
}
}
return instance;
}
}
有些人认为使用 volatile 的原因是可见性,也就是可以保证线程在本地不会存有 instance 的副本,每次都是去主内存中读取。 但其实是不对的。使用 volatile 的主要原因是其另一个特性:禁止指令重排序优化。 在 volatile 变量的赋值操作后面会有一个内存屏障(生成的汇编代码上),读操作不会被重排序到内存屏障之前。 比如上面的例子,取操作必须在执行完 1-2-3 之后或者 1-3-2 之后,不存在执行到 1-3 然后取到值的情况。从「先行发生原则」的角度理解的话,就是对于一个 volatile 变量的写操作都先行发生于后面对这个变量的读操作(这里的“后面”是时间上的先后顺序)。
但是特别注意在 Java 5 以前的版本使用了 volatile 的双检锁还是有问题的。其原因是 Java 5 以前的 JMM (Java 内存模型)是存在缺陷的,即时将变量声明成 volatile 也不能完全避免重排序,主要是 volatile 变量前后的代码仍然存在重排序问题。这个 volatile 屏蔽重排序的问题在 Java 5 中才得以修复,所以在这之后才可以放心使用 volatile。
相信你不会喜欢这种复杂又隐含问题的方式,当然我们有更好的实现线程安全的单例模式的办法。
线程安全 实现难度: 一般 描述: 这种方式能达到双检锁方式一样的功效,但实现更简单 对静态域使用延迟初始化,应使用这种方式而不是双检锁方式 这种方式只适用于静态域的情况,双检锁方式可在实例域需要延迟初始化时使用。 这种方式同样利用了 classloder 机制来保证初始化 instance 时只有一个线程,它跟第 3 种方式不同的是:第 3 种方式只要 Singleton 类被装载了,那么 instance 就会被实例化(没有达到 lazy loading 效果),而这种方式是 Singleton 类被装载了,instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用,只有通过显式调用 getInstance 方法时,才会显式装载 SingletonHolder 类,从而实例化 instance。想象一下,如果实例化 instance 很消耗资源,所以想让它延迟加载,另外一方面,又不希望在 Singleton 类加载时就实例化,因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载,那么这个时候实例化 instance 显然是不合适的。这个时候,这种方式相比第 3 种方式就显得很合理
public class Singleton {
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
JDK5 起,线程安全实现单例模式的最佳方法。 最简洁,自动支持序列化机制,绝对防止多次实例化。 Effective Java 作者 Josh Bloch 提倡的方式:
public enum Singleton {
INSTANCE;
public void whateverMethod() {
}
}
不推荐懒汉方式,推荐饿汉式。 只有在要明确实现懒加载时,才使用第 5 种。 若涉及到反序列化创建对象时,推荐使用枚举方式。 若有其他特殊的需求,可以考虑DCL方式。