单例模式，即我们只允许一个类有且仅有一个实例对外提供服务。通常为了性能考虑，单例模式会以懒加载的形式创建，也即单例中的懒汉模式，与之相对的当然就是单例的饿汉模式：不管用不用，我可以先给你创建出来。

1.单线程下的单例模式实现

非多线程环境下，由于不存在线程对共享数据(对象)的竞争，所以也就没有线程安全问题，其单例模式实现如下：

public final class FooSingleton {

    //持有类的唯一实例
    private static FooSingleton instance = null;

    /**
     * 私有构造函数
     */
    private FooSingleton() {
        //do nothing
    }

    /**
     * 提供外部获取实例的工厂方法
     * 非线程安全
     * @return
     */
    private static FooSingleton getInstance(){
        if (null == instance) {//非线程安全
            instance = new FooSingleton();
        }
        return instance;
    }

    public void methodOther() {
        //类提供的实例方法，调用方获取单例对象后，可调用类中的实例方法
    }

}

2.多线程下的单例模式实现

可以发现，在多线程环境下，这个获取单例的方法不是线程安全的：

private static FooSingleton getInstance(){
        if (null == instance) {//非线程安全
            instance = new FooSingleton();
        }
        return instance;
    }

这就会导致客户端(也就是各个调用端)获取到的对象并不是同一个对象，这显然就违背了我们使用单例模式的初衷了。怎样保证线程安全呢？常用的实现方法有如下三种：

2-1 直接加锁实现线程安全的单例模式

直接加锁实现线程安全的单例模式：

public final class FooSingletonSafety {

    //持有类的唯一实例
    private static FooSingletonSafety instance = null;

    /**
     * 私有构造函数
     */
    private FooSingletonSafety() {
        //do nothing
    }

    /**
     * 提供外部获取实例的工厂方法
     * 线程安全：加锁实现
     * synchronized保障了原子性、可见性和有序性
     * @return
     */
    private static FooSingletonSafety getInstance(){
        synchronized (FooSingletonSafety.class) {
            if (null == instance) {
                instance = new FooSingletonSafety();
            }
        }

        return instance;
    }

    public void methodOther() {
        //类提供的实例方法，调用方获取单例对象后，可调用类中的实例方法
    }

}

显然，直接加锁是可以保证单例模式的线程安全的，但是你可能会发现，这种实现方式下，每个线程在获取单例对象的时候都要去抢锁，获取之后再释放锁，这显然效率是不高的（每次获取对象都要有锁开销）。所以，一般我们会通过下面的DCL去实现线程安全的单例模式

2-2 DCL实现线程安全的单例模式

DCL，即double-check-locking双重检查锁定，代码实现如下：

public final class FooSingletonBasedDCL {

    //持有类的唯一实例
    private static volatile FooSingletonBasedDCL instance = null;

    /**
     * 私有构造函数
     */
    private FooSingletonBasedDCL() {
        //do nothing
    }

    /**
     * 提供外部获取实例的工厂方法
     * 线程安全：DCL实现
     * synchronized保障了原子性、可见性和有序性
     * volatile保证校验时(null == instance) instance对各个线程是可见的，同时禁止JIT和处理器重排序
     * @return
     */
    private static FooSingletonBasedDCL getInstance(){
        if (null == instance) {
            synchronized (FooSingletonSafety.class) {
                if (null == instance) {
                    //new关键字对应三条指令：1.分配对象所需的存储空间  2.实例化对象  3.将对象引用赋值给变量
                    //这三条指令正常执行顺序是1->2->3，但是JIT编译器或处理器在执行时可能会将其优化为1->3->2
                    //所以，为了保证instance的可见性以及禁止重排序，所以instance变量必须要用volatile修饰
                    //否则，极端情况下，一个线程在判断if (null == instance)时，instance不为空直接返回，但此时
                    //instance可能是个半对象(对象并没有经过构造方法初始化)，这将会造成代码错误
                    instance = new FooSingletonBasedDCL();
                }
            }
        }

        return instance;
    }

    public void methodOther() {
        //类提供的实例方法，调用方获取单例对象后，可调用类中的实例方法
    }

}

DCL你可能开发中基本没用过，但是这种实现方式在很多开源框架如Spring、dubbo等中都有使用

2-3 利用类加载机制实现线程安全的单例模式

利用Java的类加载机制：加载->链接->初始化，我们可以轻易的实现线程安全的单例模式，这种单例模式形式最简单，代码实现如下：

原理：Java类的初始化只会发生一次(同一个类加载器下)

public final class BarSingleton {
    //利用类初始化只会发生一次，创建线程安全的单例
    private static final BarSingleton INSTANCE = new BarSingleton();

     /**
     * 私有构造函数
     */
    private BarSingleton() {
        //do nothing
    }

    public static BarSingleton getInstance() {
        return INSTANCE;
    }

    public void methodOther() {
        //类提供的实例方法，调用方获取单例对象后，可调用类中的实例方法
    }
}