单例模式的几种Java实现

Posted 2020-11-27 Less is more

 

一、饥饿模式：

典型的空间换时间，当类装载的时候就会创建类实例，不管你用不用，先创建出来，然后每次调用的时候，就不需要判断了，节省了运行时间。

 1 public class HungrySingleton {
 2 
 3     private static HungrySingleton instance = new HungrySingleton();
 4 
 5     // 私有构造方法
 6     private HungrySingleton() {}
 7 
 8     public static HungrySingleton getInstance() {
 9         return instance;
10     }
11 }

二、懒汉模式

  1. 非线程安全的实现

 1 public class LazyUnsafeSingleton {
 2 
 3     private static LazyUnsafeSingleton instance = null;
 4 
 5     private LazyUnsafeSingleton() {
 6     }
 7 
 8     public static LazyUnsafeSingleton getInstantce() {
 9         // 此处线程不安全，可能会出现重复创建
10         if (instance == null) {
11             instance = new LazyUnsafeSingleton();
12         }
13         return instance;
14     }
15 }

 2.线程安全（双重检查锁）实现

public class LazySafeSingleton {

    private static volatile LazySafeSingleton instance = null;

    private LazySafeSingleton() {
    }

    public static LazySafeSingleton getInstance() {
        if (instance == null) {
            synchronized (LazySafeSingleton.class) {
                if (instance == null) {
                    instance = new LazySafeSingleton();
                }
            }
        }
        return instance;
    }
}

三、利用静态内部类实现

public class StaticInnerClassSingleton {

    private static class SingletonHolder {
        // 静态初始化器，由JVM来保证线程安全
        private static StaticInnerClassSingleton instance = new StaticInnerClassSingleton();
    }

    private StaticInnerClassSingleton() {}

    /**
     * 1. 当getInstance方法第一次调用的时候，它第一次读取SingletonHolder.instance,
     *    导致内部类 SingletonHolder得到初始化； 
     * 2. 而这个类在装载并初始化的时候，会初始化它的静态域，从而创建StaticInnerClassSingleton
     *    的实例，由于是静态的域，因此只会在虚拟机装载类的时候初始化一次，并由虚拟机来保证它的线程安全性；
     *
     */
    public static StaticInnerClassSingleton getInstance() {
        return SingletonHolder.instance;
    }
}

四、利用枚举实现