单例模式的六种写法

名词解释：

lazy loading(懒加载)：意思就是不在类加载的时候不初始化，而是在调用方法的时候初始化。

1、懒汉式（线程不安全）

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

优点：lazy loading

缺点：多线程下不能工作。

2、懒汉式（线程安全）

public class Singleton {
    private static Singleton instance;
    private Singleton (){}

    public static synchronized Singleton getInstance() {
        if(instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

这种仅仅在在第一种的基础上给getInstance( )加了一把锁。

优点：lazy loading，线程安全

缺点：效率低下

3、双重校验的方式

public class Singleton {
    private static volatile Singleton instance;
    private Singleton (){}

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

优点：线程安全，效率上相对2来说高一点，lazy loading

缺点：效率上还是不高

4、饿汉式

public class Singleton {
	private static Singleton instance = new Singleton();
	private Singleton (){}

	public static Singleton getInstance() {
		return instance;
	}
}

优点：让instance在类加载的时候初始化，由于静态变量只会在类加载的时候初始化一次，从而避免多线程初始化的情况。

缺点：在类加载的时候就会实例话，所以不是lazy loading，

5、静态内部类

public class Singleton {
    private static class SingletonHolder{
        private static final Singleton INSTANCE = new Singleton();
    }
    private Singleton (){}

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

优点：由于静态内部类跟外部类是平级的，所以外部类加载的时候不会影响内部类，因此实现了lazy loading；同时也是利用静态变量的方式，使得INSTANCE只会在SingletonHolder加载的时候初始化一次，从而保证不会有多线程初始化的情况，因此也是线程安全的。

这个也是最合理最常规的实现单例模式的方式，推荐。

6、枚举

public enum Singleton{
    INSTANCE;
    public void whateverMerhod() {
        
    }
}

这种是实现单例模式不太常规但是很合理的方式。