23种设计模式—— 单例设计模式

定义:

单例（Singleton）模式是设计模式中最简单的形式之一。这一模式的目的是使得类的一个对象成为系统中的唯一实例。

动机（引用百度百科）:

解决的思路：

（1）我们知道对象的创建是通过构造方法，如果构造方法私有，是否就可以阻止外部创建对象？答：可以
（2）如果构造方法私有化，怎么创建对象？答：创建类的成员变量，在类内部创建对象。
（3）如果内部创建对象，如何返回对象？答：创建一个public方法，返回对象。
（4）普通成员方法是数据属于对象的，可构造方法都私有化了，外部不发创建对象，那如何访问返回对象的方法呢？答：将该方法改成static，因为static的方法能通过类直接访问。
（5）如果返回方法用static修饰了，编译会出错，因为创建的对象成员变量不是static的，怎么办？答：将成员变量也修改为static的。

场景模拟

模拟地球超人克拉克案例：

一、经典懒汉式单例模式，即什么时间用，什么时间创建对象

/**
 * 懒汉，线程不安全
 * 
 */
public class SuperMan {
    private String name;
    // 创建一个private static final修饰的，SuperMan类型的成员变量
    private static SuperMan superMan = null;

    private SuperMan(String name) { // 构造函数私有化，不让外部创建对象
        this.name = name;
    }

    public void fly() {
        System.out.println(this.name + "...在飞");
    }

    public static SuperMan getInstance() { // 公有静态方法，返回创建的对象引用
        if (superMan != null) { // 判断如果对象为空，才创建，否则返回原对象
            superMan = new SuperMan("克拉克");
        }
        return superMan;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void otherFunction() { // 这是模拟单例类扮演其他角色
        System.out.println("otherFunction running...");
    }

}

总结：
优点：此模式在调用 getInstance()并实例为null时创建实例，这种技术又被称之为延迟加载（Lazy Load），规避了过早创建实例的问题。
缺点：线程不安全，如果两个线程同一时刻去访问getInstance()的时候,可能线程1正在创建实例时，线程2判断实例为空，就会创建多个实例。

二、懒汉式单例模式改进版

/**
 * 懒汉，线程安全
 * 
 */
public class SuperMan {
    private String name;
    private static SuperMan superMan = null;// 不能设置成final的了，因为final的必须赋初值

    private SuperMan(String name) { // 构造函数私有化，不让外部创建对象
        this.name = name;
    }

    public void fly() {
        System.out.println(this.name + "...在飞");
    }

    public static synchronized SuperMan getInstance() { // 公有静态方法，返回创建的对象引用
        if (superMan != null) { // 判断如果对象为空，才创建，否则返回原对象
            superMan = new SuperMan("克拉克");
        }
        return superMan;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void otherFunction() { // 这是模拟单例类扮演其他角色
        System.out.println("otherFunction running...");
    }

}

总结：
优点：此改进模式在getInstance()上加入线程同步锁，避免了线程不安全的问题
缺点：若使用时，多次调用getInstance()，则每次均需要线程锁的判断，消耗资源，影响效率。若已知只进行少次调用时可选择此种方案。

三、懒汉式单例模式改进版（双重校验）

/**
 * 懒汉，线程安全
 * 
 */
public class SuperMan {
    private String name;
    private static SuperMan superMan = null;// 不能设置成final的了，因为final的必须赋初值

    private SuperMan(String name) { // 构造函数私有化，不让外部创建对象
        this.name = name;
    }

    public void fly() {
        System.out.println(this.name + "...在飞");
    }

    public static SuperMan getInstance() { // 公有静态方法，返回创建的对象引用
        if (superMan != null) { // 判断如果对象为空，才创建，否则返回原对象
            synchronized (SuperMan.class) {
                if (superMan != null) {
                    superMan = new SuperMan("克拉克");
                }
            }
        }
        return superMan;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void otherFunction() { // 这是模拟单例类扮演其他角色
        System.out.println("otherFunction running...");
    }

}

总结：
优点：此改进模式在getInstance()上加入双层判断，只有在实例未创建时进行锁的判断，之后再次调用只判断实例是否为null。保证了线程的安全，提高了效率。
缺点：代码相对较复杂。

四、饿汉式单例模式，即类一加载就创建该类的对象

/**
 * 饿汉，线程安全
 * 
 */
public class SuperMan {
    private String name;
    // 创建一个private static final修饰的，SuperMan类型的成员变量
    // 让该引用指向创建的对象，注意：一定要设置成私有的，否则，外部直接通过类名就可以访问，破坏了封装性
    private static final SuperMan superMan = new SuperMan("克拉克");

    private SuperMan(String name) { // 构造函数私有化，不让外部创建对象
        this.name = name;
    }

    public void fly() {
        System.out.println(this.name + "...在飞");
    }

    public static SuperMan getInstance() { // 公有静态方法，返回创建的对象引用
        return superMan;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void otherFunction() { // 这是模拟单例类扮演其他角色
        System.out.println("otherFunction running...");
    }
}

总结：
优点：对象在类加载的时候就进行创建，实例在整个程序周期都存在。它只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。
缺点：饿汉模式是在类加载的时候创建一次实例，及时某些情况下不适用该实例(例如只调用otherFunction方法)，进而影响了类加载的速度，并过早地创建实例，从而降低内存的使用效率。

五、饿汉式单例模式（改）

/**
 * 饿汉，线程安全
 * 
 */
public class SuperMan {
    private String name;
    private static SuperMan superMan = null;

    static {
        superMan = new SuperMan("克拉克");
    }

    private SuperMan(String name) { // 构造函数私有化，不让外部创建对象
        this.name = name;
    }

    public void fly() {
        System.out.println(this.name + "...在飞");
    }

    public static SuperMan getInstance() { // 公有静态方法，返回创建的对象引用
        return superMan;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void otherFunction() { // 这是模拟单例类扮演其他角色
        System.out.println("otherFunction running...");
    }

}

总结：引入构造代码块，写法不同，原理与上一种一致。

六、静态内部类

/**
 * 线程安全，也是一种懒加载模式。
 * 
 */
public class SuperMan {
    private String name;

    //静态内部类，静态内部类中的静态成员只在第一次使用的时候加载，因此保证了线程安全。
    private static class SingleSuperManModel{
        private final static SuperMan superMan = new SuperMan("克拉克");

    }

    private SuperMan(String name) { // 构造函数私有化，不让外部创建对象
        this.name = name;
    }

    public void fly() {
        System.out.println(this.name + "...在飞");
    }

    public static SuperMan getInstance() { // 公有静态方法，返回创建的对象引用
        return SingleSuperManModel.superMan;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void otherFunction() { // 这是模拟单例类扮演其他角色
        System.out.println("otherFunction running...");
    }

}

总结：这种模式使用了一个私有的静态内部类，来存储外部类的单例。利用静态内部类的特性，外部类的 getinstance() 方法，可以直接指向内部类持有的对象。即可实现懒加载，又保证了线程的安全。