单例模式（手写）

单例模式

1. 饿汉式-线程安全

public class Singleton {
    private static Singleton uniqueInstance = new Singleton(); //私有静态变量

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

    public static Singleton getUniqueInstance() { //公有静态函数
        return uniqueInstance;
    }
}

优点： 采取直接实例化 uniqueInstance 的方式，所以不会产生线程不安全的问题。

缺点： 直接实例化的方式丢失了延迟实例化带来的节约资源的好处。

场景： JDK中 java.lang.Runtime; 里使用了饿汉式。

2. 懒汉式-线程不安全

public class Singleton {
    private static Singleton uniqueInstance; //私有静态变量

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

    public static Singleton getUniqueInstance() { //公有静态函数
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

优点： 没有用到该类时，就不会实例化，节约了资源。

缺点： 在多线程环境下是不安全的。因为如果多个线程同时进入 if (uniqueInstance == null) ，那么就会有多个线程执行 uniqueInstance = new Singleton(); 语句，导致实例化多次 uniqueInstance 。

3. 懒汉式-线程安全

public class Singleton {
    private static Singleton uniqueInstance; //私有静态变量

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

    public static synchronized Singleton getUniqueInstance() { //公有静态函数
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

优点： 没有用到该类时，就不会实例化，节约了资源。而且多线程环境下，一个时间点只能有一个线程能够进入 getUniqueInstance 方法，从而避免了实例化多次 uniqueInstance 的线程不安全问题。

缺点： 当一个线程进入 getUniqueInstance 方法后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此存在性能问题。

4. 双重校验锁-线程安全

public class Singleton {
    private volatile static Singleton uniqueInstance; //私有静态变量

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

    public static Singleton getUniqueInstance() { //公有静态函数
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

要点：

• 双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。
• 如果没有第二个 if ，那么多个线程都可能进入第一个 if 语句块中，然后先后拿锁进行实例化操作。因此必须使用双重校验锁，也就是再加一个 if 语句块。
• 为什么要加 volatile 关键字来修饰 uniqueInstance ？这里是为了禁止指令重排。因为 uniqueInstance = new Singleton(); 这段代码其实是分为三步执行的：
  • ① 为 uniqueInstance 分配内存空间
  • ② 初始化 uniqueInstance
  • ③ 将 uniqueInstance 指向分配的内存地址
  • 但是由于 JVM 有指令重排的特性，所以执行顺序有可能变成 1 -> 3 -> 2 ，在单线程环境下不会出现问题，但是在多线程环境下会导致线程获得还没有初始化的实例。所以这里要使用 volatile 关键字来禁止指令重排，来保证在多线程环境下也能正常运行。

5. 静态内部类实现

public class Singleton {
    private static class SingeltonHolder {
        private static Singleton INSTANCE = new Singleton(); //内部类 —— 私有静态变量
    }

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

    public static Singleton getUniqueInstance() { //公有静态函数
        return SingeltonHolder.INSTANCE;
    }
}

要点： 当 Singleton 类被加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。