单例设计模式

一.类结构图

二.设计思路

（1）将类的构造方法私有化，使其不能在类的外部通过 new 关键字来创建该类对象。

（2）在该类内部定义一个唯一的对象，并且将其封装为 private static 类型。

（3）定义一个静态方法返回这个唯一对象。

三.代码实现

1.饿汉模式

饿汉模式：就是使用类的时候已经将对象创建完毕（不管以后会不会使用到该对象，先创建了再说，很着急的样子，故又被称为“饿汉模式”），常见的实现办法就是直接 new 一个对象。

public class Singleton {

    private static final Singleton instance = new Singleton();
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该对象
    public static Singleton getInstance() {
        return instance;
    }
}

优点：实现起来简单，没有多线程同步问题。

缺点：当类 Singleton 被加载的时候，会初始化 static 的变量，静态变量被创建并分配内存空间，从这以后，这个 static 修饰的对象便一直占着这段内存（即便你还没有用到这个对象），当类被卸载时，静态变量被摧毁，并释放所占有的内存，因此在某些特定条件下会耗费内存。

---

2.懒汉模式

懒汉模式：就是调用 getInstance() 方法时，才创建实例对象（先不着急创建对象实例 ，等要用的时候才会创建。不着急，故又称为“懒汉模式”），常见的实现方法就是在 getInstance() 方法中进行 new 一个实例化对象。

public class Singleton {

    private static Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：实现起来比较简单，当类 Singleton 被加载的时候，静态变量 static 的instance 未被创建也没有分配内存空间，当 getInstance（）方法第一次被调用时，才初始化 instance 变量，并为其分配内存，因此在某些特定条件下会节约了内存。

缺点：在多线程环境中，这种实现方法是完全错误的，根本不能保证单例的状态。

3.双重校验锁（线程安全）

public class Singleton {

    private static volatile Singleton instance;
    
    // 构造方法私有化
    private Singleton() {}
    
    // 静态方法返回该实例
    public static Singleton getInstance() {
        // 第一次检查 instance 是否被实例化出来，如果没有进入if块
        if(instance == null) {
            synchronized (Singleton.class) {
                // 某个线程取得了类锁，实例化对象前第二次检查 instance 是否已经被实例化出来，如果没有，才最终实例出对象
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

此方法是单例模式的最佳实现方式。效率高，线程安全。

• 第一次判空是位了保证是单例，只有初始是空的情况下才可以创建对象，synchronize 里头的判空是为了避免小概率事件发生，比如当对象还没被创建时，有两个线程都通过了外部判空，进入synchronize入口处，此时由于同步加锁，只有一个线程可以执行 synchronize 内部的代码（生成单例对象），当它执行完释放了锁后，第二个线程就进入的 synchronize 内部的代码，如果此时不再判断一下的话，该对象就再次被创建了。