前言

作为一个好学习的程序开发者，应该会去学习优秀的开源框架，当然学习的过程中不免会去阅读源码，这也是一个优秀程序员的必备素养，在学习的过程中很多人会遇到的障碍，那就是设计模式。很多优秀的框架会运用设计模式来达到事半功倍的效果。鉴于自己之前对设计模式的生疏，在阅读源码时遇到设计模式的巧妙运用理解比较吃力。最近搞了一本新书 《图解设计模式》（目测讲的很基础）开始学习设计模式，对今后学习源码打下坚实的基础。后续我在阅读本书的过程中，我将记录下自己学习总结。今天就从最常使用的单例模式说起。

单例模式

在许多时候整个系统只需要拥有一个的全局对象，这样有利于我们协调系统整体的行为。比如在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。(维基百科)。

懒汉式

在单例模式中，有一种称为懒汉式的单例模式。顾名思义，懒汉式可以理解使用时才进行初始化，它包括私有的构造方法，私有的全局静态变量，公有的静态方法，是一种懒加载机制。

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        System.out.println("初始化");
    }

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

上面是最常见的懒汉式单例模式的写法，但是如果在多线程的情况下，上述方法就会出现问题，它达不到只有一个单例对象的效果，例如当某个线程1调用getInstance（）方法并判断instance == null
，此时（就在判断为空后new Singleton()之前）另一个线程2也调用getInstance（）方法，由于此时线程1还没有new出对象，则线程2执行getInstance（）中instance 也为空，那么此时就会出现多个实例的情况，而达不到只有一个实例的目的。

懒汉式（线程安全）

在上述实现中我们提到的懒汉式单例模式是一种非线程安全的，非线程安全即多线程访问时会生成多个实例。那么怎么样实现线程安全呢，也许你应该已经想到使用同步关键字synchronized。

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        System.out.println("初始化");
    }

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

使用同步关键字后，也就实现了线程安全访问，因为在任何时候它只能有一个线程调用 getInstance() 方法。那么你可能会发出疑问，这样加入同步，在高并发情况下，效率是很低的，因为真正需要同步的是我们第一次初始化的时候，是的，所以我们要进行进一步的优化。

双重检测机制

双重检测顾名思义就是两次检测，一次是检测instance 实例是否为空，进行第一次过滤，在同步快中进行第二次检测，因为当多个线程执行第一次检测通过后会同时进入同步快，那么此时就有必要进行第二次检测来避免生成多个实例。

public class Singleton {

    private static Singleton instance;

    private Singleton() {
        System.out.println("初始化");
    }

    public static Singleton getInstance() {
        if(instance==null){
            synchronized (Singleton.class) {
                if (instance == null) { 
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

对于上面的代码时近乎完美的，既然说近乎完美，那肯定还是有瑕疵的，瑕疵出现的原因就是instance = new Singleton();这一句代码，你可能会问，这会有什么问题，其实我也不知道，哈哈。在计算机语言中，初始化包含了三个步骤

1. 分配内存
2. 执行构造方法初始化
3. 将对象指向分配的内存空间

由于java编译器为了尽可能减少内存操作速度远慢于CPU运行速度所带来的CPU空置的影响，虚拟机会按照自己的一些规则(这规则后面再叙述)将程序编写顺序打乱——即写在后面的代码在时间顺序上可能会先执行，而写在前面的代码会后执行——以尽可能充分地利用CPU就会出现指令重排序(happen-before)，从而导致上面的三个步骤执行顺序发生改变。正常情况下是123，但是如果指令重排后执行为1,3,2那么久会导致instance 为空，进而导致程序出现问题。

既然已经知道了上述双重检测机制会出现问题，那么我们该怎么避免出现呢，该如何解决呢，最好的办法就是不要使用，开个玩笑啦。java中有一个关键字volatile，他有一个作用就是防止指令重排序，那么我们把singleton用volatile修饰下就可以了，如下。

private volatile static Singleton singleton;

饿汉式

饿汉式与懒汉式区别是它在类加载的时候就进行初始化操作，而懒汉式是调用getInstance()方法时才进行初始化。

public class Singleton{
    private static final Singleton instance = new Singleton();
    
    private Singleton() {
        System.out.println("初始化");
    }

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

与懒汉式相比，它是线程安全的（无需用同步关键字修饰），由于没有加锁，执行效率也相对较高，但是也有一些缺点，在类加载时就初始化，会浪费内存。

静态块实现方式

public class HungrySingleton implements Serializable {
    private static  HungrySingleton instance = null;
    static {
        instance = new HungrySingleton();
    }
    private HungrySingleton() {
        System.out.println("初始化");
    }

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

静态内部类实现方式

public class Singleton {
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    private Singleton() {
        System.out.println("初始化");
    }

    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

静态内部类相对实现较为简单，并且它是一种懒加载机制， 当Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有显示通过调用 getInstance 方法时，才会显示装载 SingletonHolder 类，从而实例化 instance。

枚举方式

public enum EnumSinglton {
    INSTANCE;

    private EnumSinglton() {
        System.out.println("构造方法");
    }
    public void  doSomething() {
        System.out.println("调用单例方法");
    }

}

枚举方式实现的单例模式是一种线程安全的单例模式。

序列化对单例模式的影响

通过上面我们对单例模式的学习，对单例模式有了进一步的学习，当我们有序列化的需求之后，那么会产生怎样的效果呢？先通过下面的代码来看下结果

public class Main {
    public static void main(String[] args) throws Exception {

        //测试序列化对单例模式的影响
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        new ObjectOutputStream(bos).writeObject(LazySingleton.getInstance());
        ByteArrayInputStream bin = new ByteArrayInputStream(bos.toByteArray());
        LazySingleton singleton = (LazySingleton) new ObjectInputStream(bin).readObject();
        System.out.println(singleton == LazySingleton.getInstance());//false
        System.out.println( EnumSinglton.INSTANCE == EnumSinglton.INSTANCE );//true
    }
}

通过我们的测试瞬时就懵逼了，除了通过枚举方式实现的单例模式，其它几种实现都生成了多个实例。那么该如何解决呢？难道反序列话只能生成多个实例。当然不是。我们可以看下面修改后的代码

public class HungrySingleton implements Serializable {
    private static  HungrySingleton instance = new HungrySingleton();
    //饿汉式变种5
    static {
        instance = new HungrySingleton();
    }
    private HungrySingleton() {
        System.out.println("初始化");
    }

    public static HungrySingleton getInstance(){
        return instance;
    }

    /**
     * 如果序列化，需要加入此方法，否则单例模式无效
     * @see java.io.ObjectStreamClass
     * @return
     */
    private Object readResolve() {
        return instance;
    }

}

好了，关于单例模式到这里已经介绍完毕了。有问题欢迎留言指出，Have a wonderful day .