[design pattern](7) Singleton

前言

上面的章节中，我们介绍了工厂模式，它是创建型模式的一种。本章我们将会介绍单例模式，它也是创建型模式的一种。单例模式是我们比较常用的一个设计模式，也是最简单的一种设计模式。

单例模式

介绍：确保在一个jvm中某个类有且只有一个实例。

类图：

从上面的类图中，我们可以总结出以下几点：

单例模式需要实现一个私有的构造函数，防止有外部的语句会实例化该类。
单例模式需要定义一个静态成员变量，用来指向该类的唯一实例。
单例模式需要定义一个静态成员方法，用来返回该类唯一的实例。

单例模式的实现

单例模式的实现方式有8种，下面让我们分别来看一看这几种实现方式的区别。

饿汉模式

代码：

public class Singleton {
    private Singleton() {
　　　　if (singleton != null) {
　　　　　　throw new RuntimeException();
　　　　}
　　}
    private static Singleton singleton = new Singleton();
    public static Singleton initSingleton() {
        return singleton;
    }
}

是否是懒加载：否
是否线程安全：是
优点：不用加锁，执行效率高。
缺点：类加载时就初始化，浪费内存。

饿汉模式（静态代码块初始化）

代码：

public class Singleton {
    private Singleton() {

　　　　if (singleton != null) {
　　　　　　throw new RuntimeException();
　　　　}

　　}
    private static Singleton singleton;
    static {
        singleton = new Singleton();
    }
    public static Singleton initSingleton() {
        return singleton;
    }
}

是否是懒加载：否
是否线程安全：是
优点：不用加锁，执行效率高。
缺点：类加载时就初始化，浪费内存。

懒汉模式

import java.util.Objects;

public class Singleton {
    private Singleton() {

　　　　if (singleton != null) {
　　　　　　throw new RuntimeException();
　　　　}

　　}
    private static Singleton singleton;
    public static Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

是否是懒加载：是
是否线程安全：否
优点：不用加锁，执行效率高，第一次调用时初始化，避免了浪费内存。
缺点：非线程安全，多线程环境下，可能会产生多个实例。

懒汉模式（线程安全）

import java.util.Objects;

public class Singleton {
    private Singleton() {
　　　　synchronized(Singleton.class) {
　　　　　　if (Objects.nonNull(singleton)) {
　　　　　　　　throw new RuntimeException();
　　　　　　}
　　　　}
　　}
    private static Singleton singleton;
    public static synchronized Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

是否是懒加载：是
是否线程安全：是
优点：第一次调用时初始化，避免了浪费内存。
缺点：实现了synchronized方法，会影响执行效率。

懒汉模式（同步代码块）

import java.util.Objects;

public class Singleton {
    private Singleton() {
　　　　synchronized(Singleton.class) {
　　　　　　if (Objects.nonNull(singleton)) {
　　　　　　　　throw new RuntimeException();
　　　　　　}
　　　　}
　　}
    private static Singleton singleton;
    public static Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

是否是懒加载：是
是否线程安全：否
优点：第一次调用时初始化，避免了浪费内存。
缺点：虽然实现了synchronized代码块，但是如果有多个线程同时实例化，那么有可能会产生多个实例。

双重检查模式

import java.util.Objects;

// 不能加Serializable,防止反序列化创建对象
public class Singleton {
    private Singleton() {
　　　　// 防止反射创建对象
　　　　if (Objects.isNull(singleton)) {
　　　　　　synchronized (Singleton.class) {
　　　　　　　　if (Objects.isNull(singleton)) {
　　　　　　　　　　singleton = this;
　　　　　　　　} else {
　　　　　　　　　　throw new RuntimeException();
　　　　　　　　}
　　　　　　}
　　　　} else {
　　　　　　throw new RuntimeException();
　　　　}
　　}
    private static volatile Singleton singleton;
    public static Singleton initSingleton() {
        if (Objects.isNull(singleton)) {
            synchronized (Singleton.class) {
                if(Objects.isNull(singleton)) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

是否是懒加载：是
是否线程安全：是
优点：第一次调用时初始化，避免了浪费内存。
缺点：暂无

静态内部类

public class Singleton {
    private Singleton() {
　　　　if (Objects.nonNull(singleton)) {
　　　　　　throw new RuntimeException();
　　　　}
　　}
    public static Singleton initSingleton() {
        return SingletonInstance.singleton;
    }

    public static class SingletonInstance {
        private static Singleton singleton = new Singleton();
    }
}

是否是懒加载：是
是否线程安全：是
优点：第一次调用时初始化，避免了浪费内存，效率高。
缺点：暂无

枚举

public enum Singleton {
    INSTANCE;
}

是否是懒加载：是
是否线程安全：是
优点：第一次调用时初始化，避免了浪费内存，效率高。
缺点：暂无