单例模式的应用是为了保证某个类的实例在整个系统中的唯一性。
1.常见的实现方式
public class Singleton
{
private static Singleton instance = null;
private Singleton()
{
}
public synchronized static Singleton getInstance()
{
if (null == instance)
{
instance = new Singleton();
}
return instance;
}
}
并发性。
常见的错误的写法就不列举了,直接上正确的实现:
2.提高并发性的单例实现(基于jvm类加载机制)
这里又要提出一种新的模式——Initialization on Demand Holder. 这种方法使用内部类来做到延迟加载对象,在初始化这个内部类的时候,JLS(Java Language Sepcification)会保证这个类的线程安全。
JVM在类的初始化阶段(即在Class被加载后,且被线程使用之前),会执行类的初始化。在执行类的初始化期间,JVM会去获取一个锁。这个锁可以同步多个线程对同一个类的初始化。基于这个特性,可以实现另一种线程安全的延迟初始化方案(这个方案被称之为Initialization On Demand Holder idiom):
public class SingletonJLS
{
private static class SingletonHolder
{
public final static SingletonJLS instance = new SingletonJLS();
}
public static SingletonJLS getInstance()
{
return SingletonHolder.instance;
}
}
3.基于volatile的双重检查锁定的解决方案
为了降低同步的粒度,一般的实现是采用双重校验锁机制,但是这种实现方式已经被认为是错误的,原因是因为在new 一个对象的时候,编译器进行了优化,发生了指令重排,导致多个线程获取一个对象的实例时,会发生获取的实例未初始化完成。
new一个对象可以用下面伪代码表示:
memory = allocate(); //1:分配对象的内存空间
ctorInstance(memory); //2:初始化对象
instance = memory; //3:设置instance指向刚分配的内存地址
ctorInstance(memory); //2:初始化对象
instance = memory; //3:设置instance指向刚分配的内存地址
编译器进行优化后的指令顺序如下
memory = allocate(); //1:分配对象的内存空间
instance = memory; //3:设置instance指向刚分配的内存地址
instance = memory; //3:设置instance指向刚分配的内存地址
ctorInstance(memory); //2:初始化对象
为了避免这种情况的发生,采用如下方式实现:
public class SafeDoubleCheckedLocking
{
//使用volatile ,在多线程环境下,2和3的指令重排将不会发生
private volatile static SafeDoubleCheckedLocking instance = null;
private SafeDoubleCheckedLocking()
{
}
public static SafeDoubleCheckedLocking getInstance()
{
if (null == instance)
{
synchronized (SafeDoubleCheckedLocking.class)
{
if (null == instance)
{
instance=new SafeDoubleCheckedLocking();
}
}
}
return instance;
}
}