我的博客
单例模式是我们经常用到的设计模式。
优点:如果对象的数据量比较大,单例模式可以避免重复的创建对象,保证内存中只有一份实例
缺点:不易被销毁,只有程序退出才会被销毁
首先,看一下简单的步骤
public class Singleton {
/**
* 私有静态实例,防止被引用。此处赋值null是为了实现延迟加载
*/
private static Singleton singleton = null;
/**
* 私有构造方法,防止被实例化
*/
private Singleton() {
}
/**
* 公共、静态的方法,创建实例
*
* @return Singleton
*/
public static Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
}
如果考虑多线程的情况,就可能出现创建多个实例的问题了。例如现在又两个线程,线程A和线程B,如果线程A正在创建实例,线程B访问 if (singleton == null) 判断,就会再次进入new Singleton()这行代码,这就出现创建两次实例的情况。为了避免这种情况,我们可以使用同步锁synchronized关键字
public static synchronized Singleton getInstance() {
if (singleton == null) {
singleton = new Singleton();
}
return singleton;
}
这样就保证不会出现多线程访问造成多实例的问题了。但是这里有性能问题:每次获取实例都需要获取锁,很耗费性能。其实我们只需要第一次实例化的时候用到锁。那好,我们改良一下代码。
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class){
if (singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
这样我们就保证了只对第一次实例化的情况使用了锁。但是,这里还有一个问题:由于指针重排序,造成实例还没有初始化就开始使用实例的情况。
在这里,需要温习一下java的基础知识:、
singleton = new Singleton()
这行代码都进行了哪些操作
memory = allocate(); //1:分配对象的内存空间
ctorInstance(memory); //2:初始化对象
instance = memory; //3:设置instance指向刚分配的内存地址
上述伪代码中2和3可能重新排序,出现下面的情况
memory = allocate(); //1:分配对象的内存空间
instance = memory; //3:设置instance指向刚分配的内存地址
//注意,此时对象还没有被初始化!
ctorInstance(memory); //2:初始化对象
此时线程B就会访问一个没有初始化的对象,出现异常。为了解决上述情况,我们需要稍微修改一下代码即可:把instance 声明为volatile类型,就可以实现线程安全的延迟初始化。
private volatile static Singleton singleton = null;
public static Singleton getInstance() {
if (singleton == null) {
synchronized (Singleton.class){
if (singleton == null){
singleton = new Singleton();
}
}
}
return singleton;
}
关于volatile的作用,只需要知道使用volatile上述伪代码中的指针重新排序将被禁止就行.
上述代码已经是线程安全的单例模式了,基于volatile的双重检查锁定(DOUBLE_CHECK)的解决方案。但是代码过于复杂。接下来介绍一种最简单也是最安全的单例模式。
/**
* 获得单例
*
* @return
*/
public static Singleton getInstance() {
return InstanceHolder.INSTANCE;
}
/**
* 单例持有器
*/
private static final class InstanceHolder {
private static final Singleton INSTANCE = new Singleton();
}
/**
* 禁止构造
*/
private Singleton() {
}
这种是基于类初始化的一种解决方案。JVM在类的初始化阶段(即在Class被加载后,且被线程使用之前),会执行类的初始化。在执行类的初始化期间,JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。基于这个特性,可以实现另一种线程安全的延迟初始化方案(这个方案被称之为Initialization On Demand Holder idiom)
总结:
延迟初始化降低了初始化类或创建实例的开销,但增加了访问被延迟初始化的字段的开销。在大多数时候,正常的初始化要优于延迟初始化。如果确实需要对实例字段使用线程安全的延迟初始化,请使用上面介绍的基于volatile的延迟初始化的方案;如果确实需要对静态字段使用线程安全的延迟初始化,请使用上面介绍的基于类初始化的方案。
网友评论