单例模式--设计模式1

单例模式–设计模式1

概念:

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式。在 GOF 书中给出的定义为：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

单例模式算是设计模式中最容易理解，也是最容易手写代码的模式了。

用途

单例模式有以下两个优点：

在内存里只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例（比如网站首页页面缓存）。

避免对资源的多重占用（比如写文件操作）。

懒汉式，线程不安全

最简单的最原始的懒汉模式：

在调用时产生实例不过在有多个线程并行调用 getInstance() 的时候，就会创建多个实例。也就是说在多线程下不能正常工作。

/**
* @author niyaowoa
*懒汉模式(线程不安全)
*/
public class Singleton1 {
private static Singleton1 instance = null;
private Singleton1() {}

public static Singleton1 getInstance(){
//调用时实例化
if(instance==null){
instance = new Singleton1();
}
return instance;
}
}

懒汉式，线程安全

线程安全很简单 让它同步即可

/**
* @author niyaowoa
*懒汉式（线程安全，效率低)
*/
public class Singleton2 {
private static Singleton2 instance = null;
private Singleton2(){}

public static synchronized Singleton2 getInstance(){
//加同步锁
if(instance==null){
instance = new Singleton2();
}
return instance;
}
}

虽然做到了线程安全，并且解决了多实例的问题，但是它并不高效。同步只在第一次调用时同步。这就引出了双重检验锁。

双重检验锁

/**
* @author niyaowoa
*双重检验锁
*/
public class Singleton3 {
private static Singleton3 instance = null;

private Singleton3 (){}

//双重检验锁
public static Singleton3 getInstance(){
if(instance == null){
synchronized (Singleton3.class) {
if(instance == null){
instance = new Singleton3();
}
}
}
return instance;
}
}

这段代码看起来好像可以了，可是，它是有问题。主要在于instance = new Singleton3()这句，这并非是一个原子操作，事实上在 JVM 中这句话大概做了下面 3 件事情。

1.给 instance 分配内存
2.调用 Singleton 的构造函数来初始化成员变量
3.将instance对象指向分配的内存空间（执行完这步 instance 就为非 null 了）

但是在 JVM 的即时编译器中存在指令重排序的优化。也就是说上面的第二步和第三步的顺序是不能保证的，最终的执行顺序可能是 1-2-3 也可能是 1-3-2。如果是后者，则在 3 执行完毕、2 未执行之前，被线程二抢占了，这时 instance 已经是非 null 了（但却没有初始化），所以线程二会直接返回 instance，然后使用，然后顺理成章地报错。

使用volatile。

/**
* @author niyaowoa
*双重检验锁（改进）
*/
public class Singleton3 {
//使用volatile
private volatile static Singleton3 instance = null;

private Singleton3 (){}

//双重检验锁
public static Singleton3 getInstance(){
if(instance == null){
synchronized (Singleton3.class) {
if(instance == null){
instance = new Singleton3();
}
}
}
return instance;
}
}

上面这种双重校验锁的方式用的比较广泛，他解决了前面提到的所有问题。但是，即使是这种看上去完美无缺的方式也可能存在问题，那就是遇到序列化的时候。

在单例与序列化的那些事儿一文中，Hollis就分析过单例和序列化之前的关系——序列化可以破坏单例。要想防止序列化对单例的破坏，只要在Singleton类中定义readResolve就可以解决该问题：

import java.io.Serializable;
/**
* @author niyaowoa
*使用双重校验锁方式实现单例
*/
public class Singleton4 implements Serializable{
private volatile static Singleton4 instance;
private Singleton4 (){}
public static Singleton4 getInstance() {
if (instance == null) {
synchronized (Singleton4.class) {
if (instance == null) {
instance = new Singleton4();
}
}
}
return instance;
}

private Object readResolve() {
return instance;
}
}

饿汉模式

/**
* @author niyaowoa
*饿汉模式
*/
public class Singleton5 {
//调用前创建
private static Singleton5 instance = new Singleton5();

private Singleton5(){}

public static Singleton5 getInstance(){
return instance;
}
}

这种写法不会出现并发问题，但是它是饿汉式的，在ClassLoader加载类后实例就会第一时间被创建，饿汉式的创建方式在一些场景中将无法使用：譬如实例的创建是依赖参数或者配置文件的，在getInstance()之前必须调用某个方法设置参数给它，那样这种单例写法就无法使用了。

内部静态类

/**
* @author niyaowoa
*内部静态类
*/
public class Singleton6 {
private static class SingletonHolder {
private static Singleton6 instance = new Singleton6();
}

private Singleton6() {
}
public static Singleton6 getInstance() {
return SingletonHolder.instance;
}
}

这种写法仍然使用JVM本身机制保证了线程安全问题；由于SingletonHolder是私有的，除了getInstance()之外没有办法访问它，因此它是懒汉式的；同时读取实例的时候不会进行同步，没有性能缺陷；也不依赖JDK版本。

这种方式是Singleton类被装载了，instance不一定被初始化。因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHolder类，从而实例化instance。想象一下，如果实例化instance很消耗资源，我想让他延迟加载，另外一方面，我不希望在Singleton类加载时就实例化，因为我不能确保Singleton类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化instance显然是不合适的。这个时候，这种方式就显得很合理。

枚举

public enum SingletonEnum {
/**
* 1.从Java1.5开始支持;
* 2.无偿提供序列化机制;
* 3.绝对防止多次实例化，即使在面对复杂的序列化或者反射攻击的时候;
*/
instance;
private String others;
SingletonEnum() {
}
}

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

总结

本文中介绍了几种实现单例的方法，主要包括饿汉、懒汉、使用静态内部类、双重校验锁、枚举等。还介绍了如何防止序列化破坏类的单例性。在使用时要选合适的，一般来说选饿汉就可以满足基本要求。