Java 单例模式的 6 种写法

Java 单例模式写法有很多种，不管它的写法怎么变化，都离不开这三步：
1. 私有的静态变量
2. 私有的构造方法
3. 公有的静态的获取实例的方法

1、懒汉式，线程不安全

public class Singleton1 {
    private static Singleton1 instance;
    private Singleton1() {}
    public static Singleton1 getInstance() {
        if (instance == null) {
            instance = new Singleton1();
        }
        return instance;
    }
}

懒汉就是懒加载，即在第一次调用时才初始化，避免了内存的浪费。这种方式是最基本的实现方式，这种实现不支持多线程。因为没有加锁 synchronized，在多线程不能正常工作。

2、懒汉式，线程安全

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

这种方式，在第一种方式上加了同步锁，而且能够在多线程中很好的工作，但是效率不高，因为同步锁会影响效率，而大多数 情况下不需要同步。

3、饿汉式

public class Singleton3 {
    private static Singleton3 instance = new Singleton3();
    private Singleton3() {}
    public static Singleton3 getInstance() {
        return instance;
    }
}

这种方式在类加载时就初始化，容易产生垃圾对象，浪费内存。这种方式是线程安全的，它是基于 classloder 机制避免了多线程的同步问题。

4、双重校验锁

public class Singleton4 {
    private volatile static Singleton4 singleton;
    private Singleton4() {}
    public static Singleton4 getSingleton() {
        if (singleton == null) {
            synchronized (Singleton4.class) {
                if (singleton == null) {
                    singleton = new Singleton4();
                }
            }
        }
        return singleton;
    }
}

这种方式采用双锁机制，线程安全且在多线程情况下能保持高性能。其实这是对第二种方式的强化。

5、静态内部类

public class Singleton5 {
    private static class SingletonHolder {
        private static final Singleton5 INSTANCE = new Singleton5();
    }
    private Singleton5() {}
    public static final Singleton5 getInstance() {
        return SingletonHolder.INSTANCE;
    }
}

这种方式同样利用了 classloder 机制来保证初始化 instance 时只有一个线程，它跟第 3 种方式不同的是：第 3 种方式只要 Singleton 类被装载了，那么 instance 就会被实例化（没有达到延迟加载的效果），而这种方式是 Singleton 类被装载了，instance 不一定被初始化。因为 SingletonHolder 类没有被主动使用，只有通过显式调用 getInstance 方法时，才会显式装载 SingletonHolder 类，从而实例化 instance。

如果实例化 instance 很消耗资源，所以想让它延迟加载，另外一方面，又不希望在 Singleton 类加载时就实例化，因为不能确保 Singleton 类还可能在其他的地方被主动使用从而被加载，那么这个时候实例化 instance 显然是不合适的。这个时候，这种方式相比第 3 种方式就显得很合理。

6、枚举

public enum Singleton6{  
    INSTANCE;  
    public void whateverMethod() {  
    }  
}  

这种实现方式简直是神的写法。它更简洁，不仅能避免多线程同步问题，而且自动支持序列化机制，防止反序列化重新创建新的对象，防止多次实例化。这种方式是 Effective Java 作者 Josh Bloch 提倡的方式，但是，使用的不多，因为，你我都不是神。

备注：一般情况下，
不建议使用第 1 种，线程不安全；
不建议使用第 2 种，效率不高；
第 3 种饿汉方式，可行，但是没有延时加载的效果，浪费内存
第 4 种双重校验锁，可行；
在要明确实现延迟加载效果时，使用第 5 种静态内部类；
涉及到反序列化创建对象时，可使用第 6 种枚举方式。