java并发4-单例设计方法

单例的设计方式：

第一种：非延迟加载单例类

public class Singleton {

private Singleton() {}

private static final Singleton instance = new Singleton();

public static Singleton getInstance() {

return instance;

}

}

第二种：同步延迟加载

public class Singleton {

private static Singleton instance = null;

private Singleton() {}

public static synchronized Singleton getInstance() {

if (instance == null) {

instance = new Singleton();

}

return instance;

}

}

第三种：双重检测同步延迟加载

为处理原版非延迟加载方式瓶颈问题，我们需要对 instance 进行第二次检查，目的是避开过多的同步（因为这里的同步只需在第一次创建实例时才同步，一旦创建成功，以后获取实例时就不需要同获取锁了），但在Java中行不通，因为同步块外面的if (instance == null)可能看到已存在，但不完整的实例。JDK5.0以后版本若instance为volatile则可行：

public class Singleton {

private volatile static Singleton instance = null;

private Singleton() {}

public static Singleton getInstance() {

if (instance == null) {

synchronized (Singleton.class) {// 1

if (instance == null) {// 2

instance = new Singleton();// 3

}

}

}

return instance;

}

}

双重检测锁定失败的问题并不归咎于 JVM 中的实现 bug，而是归咎于 Java 平台内存模型。内存模型允许所谓的“无序写入”，这也是失败的一个主要原因。

为展示此事件的发生情况，假设代码行 instance =new Singleton(); 执行了下列伪代码：

mem = allocate();             //为单例对象分配内存空间.

instance = mem;               //注意，instance 引用现在是非空，但还未初始化

ctorSingleton(instance);    //为单例对象通过instance调用构造函数

这段伪代码不仅是可能的，而且是一些 JIT 编译器上真实发生的。执行的顺序是颠倒的，但鉴于当前的内存模型，这也是允许发生的。JIT 编译器的这一行为使双重检查锁定的问题只不过是一次学术实践而已。

但是从JAVA2以后,JMM发生了根本的改变,分配空间,初始化,调用构造方法只会在线程的工作存储区完成,在没有

向主存储区复制赋值时,其它线程绝对不可能见到这个过程.而这个字段复制到主存区的过程,更不会有分配空间后

没有初始化或没有调用构造方法的可能.在JAVA中,一切都是按引用的值复制的.向主存储区同步其实就是把线程工作

存储区的这个已经构造好的对象有压缩堆地址值COPY给主存储区的那个变量.这个过程对于其它线程,要么是resource

为null,要么是完整的对象.绝对不会把一个已经分配空间却没有构造好的对象让其它线程可见.

第四种：使用ThreadLocal修复双重检测

借助于ThreadLocal，将临界资源（需要同步的资源）线程局部化，具体到本例就是将双重检测的第一层检测条件 if (instance == null) 转换为了线程局部范围内来作。这里的ThreadLocal也只是用作标示而已，用来标示每个线程是否已访问过，如果访问过，则不再需要走同步块，这样就提高了一定的效率。但是ThreadLocal在1.4以前的版本都较慢，但这与volatile相比却是安全的。

public class Singleton {

private static final ThreadLocal perThreadInstance = new ThreadLocal();

private static Singleton singleton ;

private Singleton() {}

public static Singleton  getInstance() {

if (perThreadInstance.get() == null){

// 每个线程第一次都会调用

createInstance();

}

return singleton;

}

private static  final void createInstance() {

synchronized (Singleton.class) {

if (singleton == null){

singleton = new Singleton();

}

}

perThreadInstance.set(perThreadInstance);

}

}

第五种：使用内部类实现延迟加载

为了做到真真的延迟加载，双重检测在Java中是行不通的，所以只能借助于另一类的类加载加延迟加载：

public class Singleton {

private Singleton() {}

public static class Holder {

// 这里的私有没有什么意义

/* private */static Singleton instance = new Singleton();

}

public static Singleton getInstance() {

// 外围类能直接访问内部类（不管是否是静态的）的私有变量

return Holder.instance;

}

}

来源： <单例模式与双重检测 - 设计模式 - Java - ITeye论坛>

来自为知笔记(Wiz)