单例模式（懒汉模式）

单例模式是结构最简单的设计模式，用于创建软件系统中独一无二的对象；但如果深入研究，单例模式也是最复杂的设计模式

 

单例模式（Singleton Pattern）：确保某一个类只有一个实例，且自行实例化，并向整个系统提供这个实例。单例模式是一种对象创建型模式

单例模式有两种不同的实现方式，饿汉式单例模式（Eager Singleton）和懒汉式单例模式（Lazy Singleton）

相比于饿汉模式，懒汉模式要复杂的多

 

本文介绍懒汉式单例模式（Lazy Singleton），代码如下

package com.design.singleton;

/**
 * 懒汉单例模式,线程不安全
 */
public class LazySingleton {

    private static LazySingleton lazySingleton = null;

    private LazySingleton(){

    }

    public static LazySingleton getInstance(){
        if (lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

通过代码可以看出，懒汉单例模式在第一次调用 getInstance 方法时，实例化 LazySingleton 对象，在类加载时并不自行实例化，这种技术称为延迟加载技术（Lazy Load），即在需要的时候进行加载实例

仔细推敲上边代码，会发现它存在线程安全问题。即在多线程情况下，当线程1进入 if (lazySingleton == null) 的判断时，lazySingleton 对象还没有创建，因此 lazySingleton 对象为空；此时，线程2也进入 if (lazySingleton == null) 的判断，这时线程1和线程2将创建两个 lazySingleton 对象，这违背了单例模式的初衷 。那么如何解决懒汉模式线程安全的问题，请看下边代码

 

package com.design.singleton;

/**
 * 懒汉单例模式
 */
public class LazySingleton {

    private static LazySingleton lazySingleton = null;

    private LazySingleton(){

    }

    public synchronized static LazySingleton getInstance(){
        if (lazySingleton == null){
            lazySingleton = new LazySingleton();
        }
        return lazySingleton;
    }
}

通过在 getInstance() 方法前加 synchronized 关键字进行线程锁定，来解决多个线程同时访问的线程安全问题。但这种方式仍然不是最好的解决方式，因为每次调用 getInstance() 方法时，都需要进行线程锁定判断，在多线程高并发访问情况下，将会导致系统性能大幅度降低。如何继续改进代码，仔细分析会发现，无须对整个 getInstance() 方法进行锁定，只需要对创建实例的代码lazySingleton = new LazySingleton() 进行锁定即可，改进代码如下

package com.design.singleton;

/**
 * 懒汉单例模式
 */
public class LazySingleton {

    private static LazySingleton lazySingleton = null;

    private LazySingleton(){

    }

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

看似解决了性能问题，但仔细推敲，会发现上边代码又存在线程安全问题

假设线程1和线程2都在调用 getInstance() 方法，此时 lazySingleton 对象为空，线程1和线程2都能通过 if 判断进入同步代码块，只是线程1进入 synchronized 锁定的代码中执行创建实例的代码时，线程2处于排队等待的状态，当线程1执行完成后，线程2并不知道实例已经创建完成，因此线程2将继续创建新的实例，这时将导致产生两个实例对象，违背了单例模式的设计思想，因此需要进一步改进代码。这时，我们使用双重检查锁定。

双重检查锁定（Double-Check Locking）：在 synchronized 锁定的代码中再进行一次 lazySingleton == null 的判断，这样就可保证线程安全

 

使用双重检查锁定的懒汉单例模式代码如下

package com.design.singleton;

/**
 * 双重检查懒汉单例模式
 * 保证线程安全
 */
public class DoubleCheckLazySingleton {

    private volatile static DoubleCheckLazySingleton doubleCheckLazySingleton = null;

    private DoubleCheckLazySingleton(){

    }

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

注意，使用双重检查锁定的懒汉单例类，需要在静态成员变量 doubleCheckLazySingleton 前增加修饰符 volatile，增加 volatile修饰符的作用是保证多个线程都能够正确处理被 volatile 修饰的静态成员变量，即 volatile 禁止指令重排序，且保证了其修饰的静态成员变量 doubleCheckLazySingleton 的内存可见性，从而实现线程安全

 

双重检查锁定实现的单例模式并不是完美的实现方式，因为 volatile 关键字会屏蔽 java 虚拟机所做的一些优化代码，这可能导致系统运行效率降低。那么有没有更好的方式实现单例模式呢？答案是有的，即在单例类中增加一个静态内部类，并在静态内部类中创建单例对象，再通过静态方法 getInstance() 将单例对象返回给外部

 

静态内部类实现的单例模式代码如下

package com.design.singleton;

/**
 * 静态内部类实现单例模式
 */
public class StaticInnerClassSingleton {

    private StaticInnerClassSingleton(){

    }

    private static class StaticInnerClass{
        private static StaticInnerClassSingleton staticInnerClassSingleton = new StaticInnerClassSingleton();
    }

    public static StaticInnerClassSingleton getInstance(){
        return StaticInnerClass.staticInnerClassSingleton;
    }
}

通过代码可以看出，StaticInnerClassSingleton 类在类加载时不会实例化 StaticInnerClassSingleton 对象，而在第一次调用getInstance() 方法时，将加载静态内部类 StaticInnerClass，并初始化静态成员变量 staticInnerClassSingleton，由 java 虚拟机保证其线程安全，使得成员变量 staticInnerClassSingleton 只能初始化一次。且 getInstance() 方法没有线程锁定，因此不会影响性能

通过这种方式实现的懒汉单例模式，既实现了延迟加载，也保证了线程安全，且不影响系统性能