创建型模式特点和分类

关注的问题：创建对象，将对象的创建和使用分离，这样的目的可以降低代码的偶尔度的问题。分为单例模式、工厂模式、抽象工厂模式、建造者模式、原型模型

单例模式（Singleton Pattern）

1. 单例介绍

单例模式（Singleton Pattern）：保证一个类只有一个实例，并提供一个访问他的全局访问点

单例类图：

单例中包含的角色：

• 单例类：包含一个实例且能自行创建这个实例类

2. 单例模式特点

1. 单例类只有一个实例对象
2. 单例对象必须由单例类自行创建
3. 单例类堆外提供一个可访问该单例的全局访问点

3. 代码演示及其优缺点

单例模式有8种实现方式：饿汉式（静态常量）、饿汉式（静态代码块）、懒汉式、双重检查、静态内部类、枚举。

3.1 饿汉式（静态常量）

/**
 * 饿汉式（静态变量）
 * 线程安全的，在类记载到内存中后，由JVM保证线程安全
 * 简单，推荐实现
 */
public class Singleton1 {
    //构造函数私有化（防止new）
    private Singleton1() {}
​
    //本类内部创建对象,静态变量
    private  final static  Singleton1 single = new Singleton1();
​
    //提供一个公有的静态方法，返回实例对象，提供给外部使用
    public static Singleton1 getInstance() {
        return single;
    }
}

优缺点：

优点：写法简单，在类加载时已经完成类的实例化，保证线程安全；

缺点：在类加载时完成了实例化（没有实现懒加载），假设没有使用这个实例，会造成内存的浪费。

3.2 饿汉式（静态代码块）

/**
 * 饿汉式(静态代码块)
 */
public class Singleton2 {
    //构造函数私有化
    private Singleton2(){}
    
    //类内部创建对象实例
    private static Singleton2 single;
    
    //在静态代码块中，创建单例对象
    static {
        single = new Singleton2();
    }
    
    //提供公有的访问点
    public static Singleton2 getInstance(){
        return single;
    }
}

优缺点和饿汉式静态变量方法一样。

3.3 懒汉式（线程不安全）

/**
 * 懒汉式(线程不安全)
 */
public class Singleton3 {
    private static Singleton3 single;
​
    private Singleton3 (){}
​
    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static Singleton3 getInstance() {
        if (single == null) {
            single = new Singleton3();
        }
        return single;
    }
}

测试结果（在多线程下不安全）：

优缺点：
优点：实现了懒加载的效果，但是只能在单线程使用

缺点：在多线程下，存在线程不安全

3.4 懒汉式(线程安全，同步方法)

/**
 * 懒汉式
 */
public class Singleton4 {
    private static Singleton4 single;
​
    private Singleton4 (){}
​
    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static synchronized Singleton4 getInstance() {
        if (single == null) {
            single = new Singleton4();
        }
        return single;
    }
}

线程安全的关键点：synchronized

优缺点：
优点：通过线程安全的关键字，解决线程安全问题

缺点：效率低下，每个线程在获取实例的时候，执行getInstance都需要进行同步，同步效率太低

3.5 懒汉式（线程安全，同步代码块）

/**
 * 懒汉式
 */
public class Singleton5 {
    private static Singleton5 single;
​
    private Singleton5() {
    }
​
    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static Singleton5 getInstance() {
        if (single == null) {
            synchronized (Singleton5.class) {
                single = new Singleton5();
            }
        }
        return single;
    }
}

对加锁做了一定优化，总体优缺点和上面一致

3.6 双重检查

/**
 * 双重检验
 */
public class Singleton6 {
    private static Singleton6 single;
​
    private Singleton6() {
    }
​
    //提供一个静态的公有的访问，当调用时，才创建实例，即懒汉式
    public static Singleton6 getInstance() {
        if (single == null) {
            synchronized (Singleton6.class) {
                if (single == null) {
                    single = new Singleton6();
                }
            }
        }
        return single;
    }
}

优点：

双重检查进行了两次的if (single == null)检查，保证线程安全性线程安全，延时加载，效率高，推荐使用

3.7 静态内部类

/**
 * 静态内部类
 * 静态内部属性 ，在类加载时进行初始化，保证线程安全
 * 采用静态内部类实现延迟加载
 */
public class Singleton7 {
    private Singleton7() {
    }
    
    //提供一个静态内部类，该类中有一个静态属性
    private static  class SingleHoler{
        private static final Singleton7 instance = new Singleton7();
    }
​
    //提供一个静态的公有的访问，直接返回SingleHoler.instance
    public static Singleton7 getInstance() {
        return SingleHoler.instance;
    }
}

优点：

线程安全：本质是通过类加载来保证线程安全

实现懒加载：只有在实际使用的时候，才会触发类的初始化，也是懒加载的一种形式

效率高：没有使用锁机制

推荐使用

3.8 枚举方式

/**
 * 枚举方式实现单例
 */
public enum  Singleton8 {
    INSTANCE;//属性
    
    //提供一个静态的公有的访问，直接返回SingleHoler.instance
    public static Singleton8 getInstance() {
        return INSTANCE;
    }
}

4. 单例再探究

4 .1 优点

• 单例模式保证在内存中只存在一个实例，减少了内存的开销
• 避免了对资源的多种占用
• 单例设置全局访问点，可以优化和共享资源的访问

4.2 缺点

单例模式一般没有接口，扩展困难，如果要进行扩展，就需要修改代码，违背了开闭原则

4.3 适用场景：

• 需要频繁创建的一些类，使用单例模式可以降低系统的内存压力，减少GC
• 某些对象实例占用资源比较多，或者实例耗时较长且经常使用的对象，采用单例形式
• 在spring中采用了单例模式，Bean可以被定义两种模式：Singleton(单例)和Prototype（多例）