单例模式中的懒汉模式和恶汉模式的区别

单例模式在我们开发中经常会用到的，不知道你所喜欢用饿汉模式还是喜欢懒汉模式呢？为什么会出现有两种方式来实现单例模式？

我看这其中必蹊跷，你怎么看？

大家都知道的是：懒汉模式会通过 判 null，然后 new 出一个实例，也就是懒汉模式会延迟加载出实例对象。还有其他的区别吗？

我们来看一下懒汉模式和饿汉模式的实现代码。

/**
 * 饿汉模式
 * @author zhou.ni 
 * @versionCode 1 <每次修改提交前+1>
 */
public class HungrySingle {

    private static final HungrySingle sInstance = new HungrySingle();

    private HungrySingle() {

    }

    public static HungrySingle getInstance() {
        return sInstance;
    }

}

在饿汉模式中，初始化变量的时候最好加上 final 关键字，这样比较严谨。

/**
 * 懒汉模式
 * @author zhou.ni 
 * @versionCode 1 <每次修改提交前+1>
 */
public class LazySingle {

    private static LazySingle sInstance = null;

    private LazySingle() {

    }

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

}

很多人奇怪，我的懒汉模式不是这样写的？为什么要这样写呢？

public static LazySingle getInstance() {
        if (sInstance == null) {
            sInstance = new LazySingle();
        }
        return sInstance;
    }

一般这样写的，在大多数情况下这样写是没问题的。但是如果在多线程并发执行的时候，就会很容易出现安全隐患。

第一个线程进来判断 sInstance == null，还没有new 出实例的时候 。这个时候第二个线程也进来了，判断的sInstance 也是 null，然后也会 new 出实例的，这样就不是我们所要的单例模式了。

那我们就需要加锁了，使用 synchronized 关键字。

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

这样我们的安全隐患就被解决了，但是同样带来了一个问题。那就是每次都要判断锁，程序的执行效率就会比较低。所以我们就应该尽量减少判断锁的次数，以提高运行效率。加上双重判断，也就是最开始的代码。

推荐使用饿汉模式，简单，安全。