饿汉模式与懒汉模式比较及优化

饿汉模式与懒汉模式常见于单例模式中，二者初始化时机，线程安全等均不一样，详细分析如下：

1、饿汉模式：

从名字去理解，它很饿，所以在加载类的时候，就进行初始化了。

//饿汉模式
public class Singleton {
    //类加载时初始化
    private static Singleton singleton = new Singleton();
    //构造器
    private Singleton(){}
    //获取实例方法
    public static Singleton getInstance(){
        return singleton;
    }
}

也可以通过静态代码块实现，效果一致

//饿汉模式
public class Singleton {
    //类加载初始化
    private static Singleton singleton = null;
    static {
        singleton = new Singleton();
    }
    //构造器
    private Singleton(){}
    //获取实例方法
    public static Singleton getInstance(){
        return singleton;
    }
}

分析：在类加载时就完成了初始化，所以类加载比较慢，但获取对象的速度快，线程安全。

2、懒汉模式：

顾名思义，比较懒，在你需要它的时候，才会进行初始化，而且还要判空。同时它是线程不安全的，多线程调用它会出问题。

//懒汉模式
public class Singleton {
    //定义
    private static Singleton singleton;
    //构造器
    private Singleton(){}
    //获取实例方法
    public static Singleton getInstance(){
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

可以通过加锁来控制线程安全

//懒汉模式
public class Singleton {
    //定义
    private static Singleton singleton;
    //构造器
    private Singleton(){}
    //获取实例方法
    public static synchronized Singleton getInstance(){
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

这种写法在getInstance()方法中加入了synchronized锁。能够在多线程中很好的工作，而且看起来它也具备很好的lazy loading，但是效率很低。

3、优化：

如果实例化singleton很消耗资源，我想让他延迟加载，可又担心线程安全问题，可以使用如下方式：

public class Singleton {
    //静态内部类
    private static class SingletonHandler{
        private static Singleton singleton = new Singleton();
    }
    //构造器
    private Singleton(){}
    //获取实例方法
    public static synchronized Singleton getInstance(){
        return SingletonHandler.singleton;
    }
}

Singleton类被装载了，singleton不一定被初始化。因为SingletonHandler类没有被主动使用，只有显示通过调用getInstance方法时，才会显示装载SingletonHandler类，从而实例化singleton。

4、比较：

饿汉模式加载慢执行快，安全性高。懒汉模式加载快执行慢，有线程安全问题，增加锁，又影响效率。