一、写在前面

在Java众多的设计模式当中，单例模式算是用的最多的设计模式之一了，接下来我将介绍一下市面上常用的几种写法以及各自的优缺点分析，废话不多说直接进入正题。

二、单例模式常见写法

众所周知“单例”顾名思义就是一个类只能有一个实例，就好比一个国家只能有一个政府一样，单例模式在写法上基本都有一个共同点：通过私有化构造器从而屏蔽掉外部类创建实例的可能（排除通过反射和反序列化操作），下面我就通过政府Government这个类来实现几种不同的单例模式。

2.1 饿汉式

饿汉式即无论程序后面用不用的到这个实例，它都会在加载该类的时候就创建一个实例。然后通过一个getInstance()的静态方法来获取该实例。下面是具体实现逻辑：

public class Government {
    private static Government INSTANCE = new Government();

    private Government() {
    }

    public static Government getInstance() {
        return INSTANCE;
    }
}

优点：
(1)饿汉式是典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要再判断了，节省了运行时间。
(2) 饿汉式是线程安全的，因为虚拟机保证只会装载一次，在装载类的时候是不会发生并发的。
缺点:
(1)在没用到的时候就创建出实例，导致浪费内存空间。
(2)在使用反射和反序列话时候会导致创建出多个实例的问题。例如以下测试代码你就会发现该问题。（Government类需要实现Serializable接口）

       public static void main(String[] args) {
        Government instance1 = Government.getInstance();
        Government instance2 = Government.getInstance();
        System.out.println(instance1);
        System.out.println(instance2);

        try {
            //通过反射获取实例3
            Class<Government> governmentClass1 = (Class<Government>) Class.forName("com.example.singlemode.Government");
            Constructor<Government> constructor1 = governmentClass1.getDeclaredConstructor(null);
            constructor1.setAccessible(true);
            Government instance3 = constructor1.newInstance();

            //通过反射获取实例4
            Class<Government> governmentClass2 = (Class<Government>) Class.forName("com.example.singlemode.Government");
            Constructor<Government> constructor2 = governmentClass2.getDeclaredConstructor(null);
            constructor2.setAccessible(true);
            Government instance4 = constructor2.newInstance();

            System.out.println(instance3);
            System.out.println(instance4);

            //通过反序列化获取实例对象
            //1.将instance1写入到磁盘
            FileOutputStream fos = new FileOutputStream("object.out");
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(instance1);
            oos.close();

            // 2. 把硬盘文件上的对象读出来
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.out"));
            Government instance5 = (Government) ois.readObject();
            ois.close();

            System.out.println(instance5);

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

执行结果：

com.example.singlemode.Government@511d50c0
com.example.singlemode.Government@511d50c0
com.example.singlemode.Government@60e53b93
com.example.singlemode.Government@5e2de80c
com.example.singlemode.Government@6f496d9f

你会发现1，2通过getInstance()方法获取的实例相同，3，4通过反射获取到的实例不同，这就是反射导致的获取多个实例的问题，5通过将1的实例写入磁盘在反序列化获取的实例和1之前的也不同，这就是反序列化导致的获取到不同实例的问题。

针对这两个问题可以采取以下方式避免，代码如下：

public class Government implements Serializable{
    private static Government INSTANCE = new Government();

    private Government() {
        //解决反射问题，一旦通过反射调用构造器创建对象后就抛出异常
        if (null != INSTANCE) {
            throw new RuntimeException();
        }
    }

    public static Government getInstance() {
        return INSTANCE;
    }

    // 防止反序列化获取多个对象的漏洞。
    // 无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到。
    // 实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。
    private Object readResolve() throws ObjectStreamException {
        return INSTANCE;
    }
}

再次运行之前的代码会发现执行到反射获取对象的地方时候回抛出异常：

解决反射导致多实例问题.png

先将反射获取对象的代码注释掉，然后看反序列化运行的结果：

com.example.singlemode.Government@511d50c0
com.example.singlemode.Government@511d50c0
com.example.singlemode.Government@511d50c0

最后一个是反序列化的，发现和之前的是同一个实例。这就说明解决了这两个问题。

2.2 懒汉式

和饿汉式不同之处就在于，它是采用懒加载在用到的时候才会去创建,代码实现如下：

public class Government {
   private static Government INSTANCE;

   private Government() {
   }

   public static Government getInstance() {
       if (INSTANCE == null) {
           INSTANCE = new Government();
       }
       return INSTANCE;
   }

}

优点：
(1) 如果一直没有使用的话，那就不会创建实例，节约内存空间
缺点：
(1)每次获取实例都会进行判断，看是否需要创建实例，浪费判断的时间。
(2)从线程安全性上讲，不加同步的懒汉式是线程不安全的，比如，有两个线程，一个是线程A，一个是线程B，它们同时调用getInstance方法，那就可能导致并发问题。
(3)在使用反射和反序列话时候会导致创建出多个实例的问题。解决方式和之前饿汉式的相似这里不做过多说明。

2.3 DoubleCheck式

DoubleCheck式也叫双重检查式，主要是进行了两重判空操作,同时增加了同步锁具体实现如下：

public class Government implements Serializable{
    private volatile static Government INSTANCE;

    private Government() {
    }

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

优点：
(1) 一直没有使用的话，那就不会创建实例，节约内存空间
(2)加了同步锁，线程安全
缺点：
(1)每次获取实例都会进行判断,第一次会持有同步锁，浪费判断的时间和性能损耗。
(2)在使用反射和反序列话时候会导致创建出多个实例的问题。解决方式和之前饿汉式的相似这里不做过多说明。

2.4 静态内部类式

静态内部类实现方式（也是一种懒加载方式），具体实现如下：

public class Government implements Serializable{

    private static class GovernmentHolder{
        private static final Government INSTANCE = new Government();
    }

    private Government() {
    }

    public static Government getInstance() {
        return GovernmentHolder.INSTANCE;
    }
}

优点：
(1) 一直没有使用的话，那就不会创建实例，节约内存空间
(2)采用静态内部类，线程安全
缺点：
(1)每次获取实例都会进行判断和持有同步锁，浪费判断的时间和性能损耗。
(2)在使用反射和反序列话时候会导致创建出多个实例的问题。解决方式和之前饿汉式的相似这里不做过多说明。

2.5 枚举式

枚举式绝对是这五种里堪称最完美的模式，简简单单的一点代码就实现了一个线程安全，lazy loading的单例，与其说是写法鬼斧神工，不如说是恰如其分地应用了enum的性质。

public enum  Government {
    INSTANCE
}

首先，我们都知道enum是由class实现的，换言之，enum可以实现很多class的内容，包括可以有member和member function，这也是我们可以用enum作为一个类来实现单例的基础。另外，由于enum是通过继承了Enum类实现的，enum结构不能够作为子类继承其他类，但是可以用来实现接口。此外，enum类也不能够被继承，在反编译中，我们会发现该类是final的。
其次，enum有且仅有private的构造器，防止外部的额外构造，这恰好和单例模式吻合，也为保证单例性做了一个铺垫。这里展开说下这个private构造器，如果我们不去手写构造器，则会有一个默认的空参构造器，我们也可以通过给枚举变量参量来实现类的初始化,例如：

public enum Color{
    RED(1),GREEN(2),BLUE(3);
    private int code;
    Color(int code){
        this.code=code;
    }
    public int getCode(){
        return code;
    }
}

三、总结

单例模式的实现形式有多种，在使用的时候根据需要恰当的选择实现形式。本文内容算是自己对单例模式的一些认识和理解，也是参考了一些前辈们的思路，这里向他们致谢。如有错误望大家指正。