设计模式-单例模式（一）单例的几种基本实现方式

单例模式
单例模式（Singleton Pattern）是指确保一个类在任何情况下都绝对只有一个实例，并提供一个全局访问点。单例模式是创建型模式。单例模式在现实生活中应用也非常广泛。例如，在 J2EE 标准中，ServletContext、ServletContextConfig 等；在 Spring 框架应用中 applicationContext；数据库的连接池也都是单例形式。

饿汉式单例

饿汉式单例是在类加载的时候就立即初始化，并且创建单例对象。绝对线程安全，在线程还没出现以前就是实例化了，不可能存在访问安全问题。
优点：没有加任何的锁、执行效率比较高，在用户体验上来说，比懒汉式更好。
缺点：类加载的时候就初始化，不管用与不用都占着空间，浪费了内存，有可能占着茅坑不拉屎。
Spring 中 IOC 容器 ApplicationContext 就是典型的饿汉式单例。
饿汉式代码如下：

public class HungrySingleton {
    private static final HungrySingleton hungrySingleton = new HungrySingleton();
    private HungrySingleton(){}
    public static HungrySingleton getInstance(){
        return hungrySingleton;
    }
}

也可以将实例初始化的过程放在静态代码块中。这两种写法都非常的简单，也非常好理解，饿汉式适用在单例对象较少的情况。

懒汉式单例
懒汉式单例的特点是：被外部类调用的时候内部类才会加载，下面看懒汉式单例的简单实现
懒汉式单例实现一：

public class LazySimpleSingleton {
    private LazySimpleSingleton(){}
    private static LazySimpleSingleton lazy = null;
    public static LazySimpleSingleton getInstance(){
    if(lazy == null){
        lazy = new LazySimpleSingleton();
    }
    return lazy;
    }
}

代码测试：
ExectorThread 类

public class ExectorThread implements Runnable{
    @Override
    public void run() {
        LazySimpleSingleton singleton = LazySimpleSingleton.getInstance();
        System.out.println(Thread.currentThread().getName() + ":" + singleton);
    }
}

LazySimpleSingletonTest 类

public class LazySimpleSingletonTest {
    public static void main(String[] args) {
        Thread t1 = new Thread(new ExectorThread());
        Thread t2 = new Thread(new ExectorThread());
        t1.start();
        t2.start();
        System.out.println("End");
    }
}

运行结果发现这个单例代码有可能会出现两次获取结果不是同一个实例的情况。意味着上面的单例存在线程安全隐患。

如何优化代码，使得懒汉式单例在线程环境下安全呢？来看下面的代码，给 getInstance()加上 synchronized 关键字，是这个方法变成线程同步方法：

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

这个时候因为getInstance 同时只能有一个线程执行，下一个线程执行的时候lazy属性肯定不为空，所以线程安全的问题解决了。但是用synchronized 加锁，在线程数量比较多情况下，会导致大批量线程出现阻塞，从而导致程序运行性能大幅下降。那么，有没有一种更好的方式，既兼顾线程安全又提升程序性能呢。看如下双重检查锁的单例模式：

public class LazyDoubleCheckSingleton {
    private volatile static LazyDoubleCheckSingleton lazy = null;
    private LazyDoubleCheckSingleton(){}
    public static LazyDoubleCheckSingleton getInstance(){
        if(lazy == null){
            synchronized (LazyDoubleCheckSingleton.class){
                if(lazy == null){
                    lazy = new LazyDoubleCheckSingleton();
                }
            }
        }
        return lazy;
    }
}

这里synchronized 只会在创建实例的时候枷锁，之后lazy不等于null,就不会出现线程阻塞的情况。但是，用到 synchronized 关键字，总归是要上锁，对程序性能还是存在一定影响的。如何优化? 看如下 采用静态内部类的实现方式:

public class LazyInnerClassSingleton {
    //默认使用 LazyInnerClassGeneral 的时候，会先初始化内部类
    //如果没使用的话，内部类是不加载的
    private LazyInnerClassSingleton(){}
    //每一个关键字都不是多余的
    //static 是为了使单例的空间共享
    //保证这个方法不会被重写，重载
    public static final LazyInnerClassSingleton getInstance(){
    //在返回结果以前，一定会先加载内部类
        return LazyHolder.LAZY;
    }
    //默认不加载
    private static class LazyHolder{
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

这种形式其实就是饿汉式+内部类，利用内部类用到才会加载的特性，解决了懒汉式不管用不用都加载带来的问题。兼顾饿汉式的内存浪费，也兼顾 synchronized 性能问题。内部类一定是要在方法调用之前初始化，巧妙地避免了线程安全问题。