创建型模式--单例模式

创建型模式的主要关注点是“怎样创建对象？”，它的主要特点是“将对象的创建与使用分离”。

这样可以降低系统的耦合度，使用者不需要关注对象的创建细节。

创建型模式分为：

1. 单例模式
2. 工厂方法模式
3. 抽象工程模式
4. 原型模式
5. 建造者模式

1.1 单例设计模式

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

1.2 单例模式的结构

单例设计模式分类两种：
饿汉式：类加载就会导致该单实例对象被创建；
懒汉式：类加载不会导致该单实例对象被创建，而是首次使用该对象时才会创建；

1.2.1 饿汉式-方式1（静态变量方式）

/**
* 饿汉式：静态成员变量方式
*/
public class Singleton {
    // 私有构造方法
    private Singleton() {}
    
    // 在本类中创建本类对象
    private static Singleton instance = new Singleton();
    
    // 提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return instance;
    }
}

public class Client {
    public static void main(String[] args) {
        Singleton instance = Singleton.getInstance();
        Singleton instance1 = Singleton.getInstance();
        System.out.println(instance == instance1);
    }
}

运行结果：
true

该方式在成员位置声明Singleton类型的静态变量，并创建Singleton类的对象instance。instance对象是随着类的加载而创建的。如果该对象足够大的话，而一直没有使用就会造成内存的浪费。

1.2.2 饿汉式-方式2（静态代码块方式）

/**
 * 饿汉式：静态代码块方式
 */
public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 创建本类对象
    private static Singleton instance;

    static {
        instance = new Singleton();
    }
    
    // 提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        return instance;
    }
}

该方式在成员位置声明Singleton类型的静态变量，而对象的创建是在静态代码块中，也是对着类的加载而创建。所以和饿汉式的方式1基本上一样，当然该方式也存在内存浪费问题。

1.2.3 懒汉式-方式1（线程不安全）

/**
 * 懒汉式：线程不安全
 */
public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 创建本类对象
    private static Singleton instance;

    // 提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

从上面代码我们可以看出该方式在成员位置声明Singleton类型的静态变量，并没有进行对象的赋值操作，当调用getInstance()方法获取Singleton类的对象的时候才创建Singleton类的对象，这样就实现了懒加载的效果。但是，如果是多线程环境，会出现线程安全问题。

1.2.4 懒汉式-方式2（线程安全）

/**
 * 懒汉式：线程安全
 */
public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 创建本类对象
    private static Singleton instance;

    // 提供一个公共的访问方式，让外界获取该对象
    public static synchronized Singleton getInstance(){
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

该方式也实现了懒加载效果，同时又解决了线程安全问题。但是在getInstance()方法上添加了synchronized关键字，导致该方法的执行效果特别低。从上面代码我们可以看出，其实就是在初始化instance的时候才会出现线程安全问题，一旦初始化完成就不存在了。

1.2.5 懒汉式-方式3（双重检查锁）

/**
 * 懒汉式：双重检查锁模式 
 */
public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 创建本类对象
    private static Singleton instance;

    // 提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        // 第一次判断，如果 instance 不为null，不进入抢锁阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                // 抢到锁之后再次判断是否为null
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

双重检查锁模式是一种非常好的单例实现模式，解决了单例、性能、线程安全问题，上面的双重检测锁模式看上去完美无缺，其实是存在问题，在多线程的情况下，可能会出现空指针问题，出现问题的原因是JVM在实例化对象的时候会进行优化和指令重排序操作。

要解决双重检查锁模式带来空指针异常的问题，只需要使用 volatile 关键字, volatile 关键字可以保证可见性和有序性。

public class Singleton {
    // 私有构造方法
    private Singleton() {}

    // 创建本类对象
    private static volatile Singleton instance;

    // 提供一个公共的访问方式，让外界获取该对象
    public static Singleton getInstance(){
        // 第一次判断，如果 instance 不为null，不进入抢锁阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                // 抢到锁之后再次判断是否为null
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

添加 volatile 关键字之后的双重检查锁模式是一种比较好的单例实现模式，能够保证在多线程的情况下线程安全也不会有性能问题。

1.2.6 枚举方式

/**
 * 枚举方式
 */
public enum Singleton {
    INSTANCE;
}

枚举方式属于饿汉式方式。