常见单例模式学习

1. 使用场景
      在我们的应用程序中，对于一些类系统中只需要一个实例就行了（例如数据库连接，一些工具类，辅具加载类等），即从始到终，应用程序系统中只存在一个该类的实例对象，每次使用到该类时，使用的都将会是同一个对象。spring默认管理的类实例就是单例模式的。

2. 单例模式的特点
    * 该类只能有一个实例
    * 类的实例必须是自身创建的
    * 向整个系统提供这个实例
      对于第二点，如何能保证自身类必须是自身创建的内，即要保证该类不能通过new的方式创建对象。此时我们需要在单例的类中，重写无参构造函数，并使用私有（private）修饰符

private Singleton(){}

单例模式结构图如下：

3. 常见的单例模式
3.1 懒汉线程不安全模式

package com.zhegui.pattern.singleton;

/**
 * 懒汉单例模式 
 *    线程不安全
 * @author Zhegui
 *
 */
public class LazySingleton {

    private LazySingleton(){}

    private static LazySingleton instance = null; 

    public static LazySingleton getInstance(){
        if(instance == null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

作为单例模式的入学教程，上面的例子是最简单的单例模式，但是该设计并不能保证系统调用时，使用的都是同一个实例对象，在并发情况下，就可能会出现两个甚至过个系统调用使用了不同的实例对象。

3.2 线程安全的懒汉模式

package com.zhegui.pattern.singleton;
/**
 * 懒汉单例模式 
 *    在方法级别使用synchronized关键字保证线程安全
 * @author Zhegui
 *
 */
public class SynLazySingleton {

    private SynLazySingleton(){}

    private static SynLazySingleton instance = null; 

    public synchronized static SynLazySingleton getInstance(){
        if(instance == null){
            instance = new SynLazySingleton();
        }
        return instance;
    }
}

这种方式可以保证线程安全的，但是同步锁是在方法上，我们知道，锁的粒度越大对于性能的消耗越大，因此考虑降低锁粒度，在代码块中加锁，双重检验单例模式（DCL）

package com.zhegui.pattern.singleton;

/**
 * 懒汉模式
 *    在代码块中使用双重校验
 * @author Zhegui
 *
 */
public class BolckSynLazySingleton {

    private BolckSynLazySingleton(){}

    private static BolckSynLazySingleton instance = null; 

    public static BolckSynLazySingleton getInstance(){

        if(instance == null){
            /**
             * 假设次数存在两条并发访问进入到此
             *     A线程先获得锁，B线程等待
             *     A线程释放锁
             *     B线程获得锁，如果不进行instance空校验，此时instance会重新创建对象
             */      
            synchronized (BolckSynLazySingleton.class) {
                if(instance == null){
                    instance = new BolckSynLazySingleton();
                }
            }
        }
        return instance;
    }
}

    以前一直觉得双重检验的方式便可以保证线程安全，直到我了解到了DCL失效的问题。
    问题主要出现在instance = new BolckSynLazySingleton();这个代码块上，在JVM中，这句代码主要归结起来需要执行三个步骤：
    1. 在堆内存中开辟内存空间
    2. 在堆内存中实例化Singleton里面的各个参数
    3. 把对象指向堆内存空间
在JVM中存在一种指指令重排序的概念，即后面两步操作的执行顺序是不一确定的。假设A1线程获得锁，并进行到了instance = new BolckSynLazySingleton();这一步操作，并且先执行构造函数中的第三步，把对象指向堆内存空间,此时instance已经不是null了，在还未来得及执行2的时候，新来了一个线程B2访问，在外层的if(instance == null)返回false，该线程返回了线程A1未初始化完成（构造函数未执行完毕）的对象，这样后面的线程B2拿到的instance使用时就会报错。解决的方法就是，使用volatile关键字，加入该关键字后就禁止了指令重排序，即instance = new BolckSynLazySingleton(); ，操作只能按照1-2-3顺序执行；另一种方式是使用后面提到的静态内部类单例模式。

private volatile static  BolckSynLazySingleton instance = null; 

3.3 饿汉模式

package com.zhegui.pattern.singleton;

/**
 * 饿汉单例模式
 * @author Zhegui
 *
 */
public class HungrySingleton {

    private HungrySingleton(){}

    private static HungrySingleton instance = new HungrySingleton();

    public static HungrySingleton getInsatnce(){
        return instance;
    }

}

饿汉模式，在类加载的时候事先创建好一个私有类实例，而不是在使用的时候再去创建，这时就不需要考虑线程安全的问题了，使用的时候就只能使用该成员变量。

3.4 枚举单例
在effective java 一书中，作者推荐我们使用枚举类型的单例模式，因为单元素枚举的单例模式即是线程安全的，写法也相等简单，保证序列化等。

package com.zhegui.pattern.singleton;

public enum EnumSingleton {

    INSTANCE;

    public void doSomething(){
        System.out.println("enum singleton doing....");
    }
}

其实枚举类型的单例模式本质也是饿汉模式，编译过后的枚举类型，同样会有一个私有构造函数，每个枚举元素就相当于静态一个私有的类成员变量，这些成员变量都是类加载的时候就实例化的，即类似于下(实际的可以查询Java枚举反编译相关资料)：

private EnumSingleton();
public static final EnumSingleton INSTANCE = new EnumSingleton();

3.5 内部类单例模式

package com.zhegui.pattern.singleton;

/**
 * 静态内部了
 * @author Zhegui
 *
 */
public class `InnerClassSingleton` {

    private InnerClassSingleton(){}

    private static class InnerSingtelonHolder{
        private static InnerClassSingleton instance = new InnerClassSingleton();
    }

    public static InnerClassSingleton getInstance(){
        return InnerSingtelonHolder.instance;
    }
}

注意，在这里，在InnerClassSingleton第一次被加载时，并不需要去加载内部类InnerSingtelonHolder，当外部第一次调用getInstance()时，才会加载内部类，此时初始化instance，这种方法不仅能确保线程安全，也能保证单例的唯一性，同时也延迟了单例的实例化。

3.6 单例模式需要实现序列化时
      注意，在单例模式中如果需要序列化，那么必须重写private Object readResolve() throws ObjectStreamException方法!!!

package com.zhegui.pattern.singleton;

/**
 * 实现序列化的单例
 *    必须覆盖readResolve，确保反序列化时得到的是同一个对象
 * @author Zhegui
 *
 */
public class SerSingleton implements java.io.Serializable {
    /**
     * 
     */
    private static final long serialVersionUID = -6405221629370661102L;

    public static SerSingleton INSTANCE = new SerSingleton();     

    protected SerSingleton() {}     

    private Object readResolve() {     
       return INSTANCE;     
    }  
}

4. 总结
      以上就是常见的单例模式，还有一些其他的单例模式笔者还没深入了解到，对于上面几种单例模式，笔者比较喜欢枚举类型和静态内部了的方式，这两种一种是饿汉（简单），一种是懒汉且线程安全。