设计模式--- 创建者模式：单例模式以及其7种实现方式

1、单例模式

单例模式（Singleton Pattern）是一种创建对象的最佳方式。
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只创建单个对象。该类提供了一种访问其唯一的对象的方式，可以直接访问，无需实例化该类的对象。

1.1 单例模式的角色

单例模式有两种角色：单例类和访问类
(1) 单例类：只能穿件一个实例的类。
(1) 访问类：使用单例类。

1.2 单例模式的实现

单例模式的实现分为两种种：饿汉式和懒汉式
(1) 饿汉式：类加载就会导致该实例对象被创建。
(1) 懒汉式：类加载不会导致该实例对象被创建，而是首次使用该对象的时候，该对象才会被创建。

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

1. 静态变量方式：
步骤：声明、创建、并对外提供访问的方式
（1）声明、创建：
在成员变量的位置声明并创建一个Singleton类型的静态成员变量。
（2）对外提供访问方式：
对外提供静态方法getInstance()，让外界获取该对象
类的加载就会创建instance对象。若该对象很大，一直没有使用就会造成内存的浪费。

/* 
 * 1 饿汉式
 *      2、在成员变量位置声明并创建该类的唯一对象
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton(){}

    // 2. 在成员变量位置中声明并创建本类的对象
    private static Singleton instance = new Singleton(); // 饿汉式：静态成员变量

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

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

2. 静态代码块方式：
步骤：声明、创建、并对外提供访问的方式
（1）声明：
在成员变量的位置声明一个Singleton类型的静态成员变量；
（2）创建：
在静态代码块位置创建该类的对象
（3）对外提供访问方式：
对外提供静态方法 getInstance()，让外界获取该对象
同样也存在内存浪费。

/*
 * 1.饿汉式
 *      2、在成员变量位置声明该类的唯一对象
 *      2.1 在静态代码块中创建该类的唯一对象
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton(){}

    // 2. 在成员变量位置中声明本类的对象
    private static Singleton instance;

    // 2.1 在静态代码块中创建本类的对象
    static {
        instance = new Singleton();
    }

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

1.2.3 方式3——懒汉式（线程不安全）

3. 懒汉式：线程不安全：
步骤：声明、创建、并对外提供访问的方式
（1）声明：
在成员变量的位置声明一个Singleton类型的静态成员变量；
（2）创建、对外提供访问方式：
在对外提供的静态方法的位置创建该类的对象；然后，对外提供静态方法getInstance()，让外界获取该对象
只在第一次使用该对象的时候才会申请创建对象，申请内存，所以不存在内存浪费。

/*
 * 2.懒汉式 - 线程不安全
 *      3、在成员变量位置声明该类对象
 *      3.1 在对外提供的静态方法中创建该对象
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton(){}

    // 2. 在成员变量位置中声明本类的对象
    private static Singleton instance;

    // 3. 提供一个公共的访问方式，让外界获取该对象
    // 3.1 在静态方法创建该对象
    public static Singleton getInstance() {
        if (instance != null) { // instance只会创建一次
            instance = new Singleton(); 
        }
        return instance;
    }
}

1.2.4 方式4——懒汉式（线程安全）

4. 懒汉式：线程安全：
步骤：声明、创建、并对外提供访问的方式与方式3完全一致，只是在对外提供的访问方式上加了synchronized关键字。
此方法的执行效果有点低。

/*
 * 2.懒汉式 - 线程安全
 *      4、在成员变量位置声明该类对象，在getInstance()方法上添加了synchronized关键字
 *      4.1 在对外提供的静态方法中创建该对象
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton(){}

    // 2. 在成员变量位置中声明本类的唯一对象
    private static Singleton instance;

    // 3. 提供一个公共的静态访问方式，让外界获取该对象
    // 3.1 在静态方法创建该对象
    // 3.2 在getInstance()方法上添加了synchronized关键字
    public static synchronized Singleton getInstance() {
        if (instance == null) { // instance只会创建一次
            instance = new Singleton();
        }
        return instance;
    }
}

1.2.5 方式5——懒汉式（双重检查锁）

5. 懒汉式：双重检查锁：
步骤：声明、创建、并对外提供访问的方式
（1）声明：
在成员变量的位置声明一个Singleton类型的静态成员变量；
（2）创建、对外提供访问方式：
在对外提供的静态方法的位置创建该类的对象，在创建对象的时候进行双重非空判断；然后，对外提供静态方法getInstance()，让外界获取该对象

/*
 * 2.懒汉式 - 双重检查锁
 *      5、在成员变量位置声明该类对象
 *      5.1 在对外提供的静态方法中创建该对象，在创建对象的时候加锁
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton(){}

    // 2. 在成员变量位置中声明本类的唯一对象
    private static Singleton instance;

    // 3. 提供一个公共的静态访问方式，让外界获取该对象
    // 3.1 在静态方法创建该对象
    // 3.2 在创建对象的时候加双重判断
    public static Singleton getInstance() {
        // 以下：进入双重检查方式阶段：
        // 第一次判断：如果instance不为null，不进入抢锁的阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                // 第二次判断：抢到锁之后，再次判断是否为null
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

以上方式，存在空指针异常问题，只需要使用 volatile 关键字可解决此问题，可以保证多线程的线程安全。 volatile 关键字可以保证可见性和有序性。

/*
 * 2.懒汉式 - 双重检查锁，加volatile关键字
 *      5、在成员变量位置声明该类对象
 *      5.1 在对外提供的静态方法中创建该对象，在创建对象的时候加锁
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton(){}

    // 2. 在成员变量位置中声明本类的唯一对象
    // 2.1 volatile关键字
    private static volatile Singleton instance;

    // 3. 提供一个公共的静态访问方式，让外界获取该对象
    // 3.1 在静态方法创建该对象
    // 3.2 在创建对象的时候加双重判断
    public static Singleton getInstance() {
        // 以下：进入双重检查方式阶段：
        // 第一次判断：如果instance不为null，不进入抢锁的阶段，直接返回实例
        if (instance == null) {
            synchronized (Singleton.class) {
                // 第二次判断：抢到锁之后，再次判断是否为null
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

1.2.6 方式6——懒汉式（静态内部类方式）

6. 静态内部类方式：
步骤：声明、创建、并对外提供访问的方式
（1）声明、创建：
在静态内部类的位置声明并创建一个final 静态成员变量；JVM 在加载外部类的过程中, 是不会加载静态内部类的, 只有内部类的属性/方法被调用时才会被加载, 并初始化其静态属性。
（2）对外提供访问方式：
对外提供静态方法 getInstance()，让外界获取该对象

/*
 * 2.懒汉式 - 静态内部类
 *      6、在静态内部类中，初始化INSTANCE
 *      6.1 JVM 在加载外部类的过程中, 是不会加载静态内部类的
 *      6.2 只有内部类的属性/方法被调用时才会被加载
 */
public class Singleton {
    // 1. 私有构造方法
    private Singleton(){}

    // 3. 内部类SingletonHolder，会在其被加载的时候初始化INSTANCE
    // 3.1 JVM 在加载外部类的过程中, 是不会加载静态内部类的,
    // 3.2 只有内部类的属性/方法被调用时才会被加载,是属于懒汉式的单例模式
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    // 2. 提供一个公共的静态访问方式，让外界获取该对象
    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

1.2.7 方式7————饿汉式（枚举方式）

（1）枚举类型是线程安全的
（2）唯一一种不会被破坏的单例实现模式。序列化和反序列化以及反射 会破坏了单例设计模式。

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

1.3 存在的问题

序列化和反序列化以及反射 会破坏了单例设计模式。

// 1、防止 序列化和反序列化 破解单例模式：
    /**
     * 下面是为了解决序列化反序列化破解单例模式
     */
    private Object readResolve() {
        return SingletonHolder.INSTANCE;
    }

//2、防止 反射破解单例模式：
    //私有构造方法
    private Singleton() {
        /*
           反射破解单例模式需要添加的代码
        */
        if(instance != null) {
            throw new RuntimeException();
        }
    }

2、原型模式

3、工厂方法模式

4、抽象工厂模式

5、建造者模式