单例模式--设计模式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 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

总结

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

---