概述

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

1.饿汉式单例模式

先来看看类结构图：

类结构图

 饿汉式单例模式在类加载的时候就立刻初始化，并且创建单例对象。他绝对线程安全，在线程出现之前就已经实例化，不存在安全访问问题。

优点：没有添加任何锁、执行效率高，用户体验比懒汉式单例模式更好。
缺点：类加载时就初始化，会造成内存浪费。（内存换效率）

来看下代码：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description 提供一个全局访问点，并隐藏所有的构造方法
 * 饿汉式单例 优点：执行效率高，没有任何锁
 * 缺点： 会造成内存浪费
 * @Date: Create in 10:34 2020/4/12
 */
public class HungrySingleton {

    private static final HungrySingleton hungrySingleton = new HungrySingleton();

    private HungrySingleton() {
    }

    public static HungrySingleton getInstance() {
        return hungrySingleton;
    }
}

静态代码块的实现方式：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 10:46 2020/4/12
 */
public class HungryStaticSingleton {

    private static final HungryStaticSingleton hungryStaticSingleton;

    static {
        hungryStaticSingleton = new HungryStaticSingleton();
    }

    private HungryStaticSingleton() {
    }

    public static HungryStaticSingleton getInstance() {
        return hungryStaticSingleton;
    }


}

 两种写法并没有本质上的区别，饿汉式单例模式适用于单例对象较少的情况。下面我们来看性能更优的写法。

2.懒汉式单例模式

 懒汉式单例模式的特点是：只有被外部类调用的时候才会生成对应单例对象的实例。下面看懒汉式单例模式的简单实现LazySimpleSingleton：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 11:17 2020/4/12
 */
public class LazySimpleSingleton {

    private static LazySimpleSingleton instance;

    private LazySimpleSingleton() {
    }

    public static LazySimpleSingleton getInstance() {
        if(instance == null) {
            //打印当前创建的实例
            System.out.println(Thread.currentThread().getName() + ":"
                    + (instance = new LazySimpleSingleton()));
        }
        return instance;
    }

}

然后写一个线程类ExectorThread：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 22:37 2020/4/12
 */
public class ExectorThread implements Runnable {
    public void run() {
        LazySimpleSingleton.getInstance();
    }
}

调用代码：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 22:40 2020/4/12
 */
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();
    }
}

运行结果：

运行结果

 可以发现，在并发情况下，上述代码有一定概率会创建两个不同的对象，破坏了实例对象的全局单例，存在线程安全隐患。下面我们用synchronized关键字来保证getInstance（）的线程安全。

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 11:17 2020/4/12
 */
public class LazySimpleSingleton {

    private static LazySimpleSingleton instance;

    private LazySimpleSingleton() {
    }

    public synchronized static LazySimpleSingleton getInstance() {
        if(instance == null) {
            System.out.println(Thread.currentThread().getName() + ":"
                    + (instance = new LazySimpleSingleton()));
        }
        return instance;
    }

}

 通过上述方法，线程安全问题解决了，但在线程数量比较多的情况下，CPU分配压力上升，则会导致大批线程阻塞，导致程序性能大幅下降。如何解决这个问题呢，来看看双重检查锁的单例模式：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 11:17 2020/4/12
 */
public class LazySimpleSingleton {

    private volatile static LazySimpleSingleton instance;

    private LazySimpleSingleton() {
    }

    public synchronized static LazySimpleSingleton getInstance() {
        if(instance == null) {
            synchronized(LazySimpleSingleton.class) {
                if(instance == null) {
                    System.out.println(Thread.currentThread().getName() + ":"
                            + (instance = new LazySimpleSingleton()));
                }
            }
        }
        return instance;
    }

 当第一个线程调用getInstance（）方法时，第二个线程也可以调用。当第一个线程执行到synchronized时会上锁，第二个线程就会变成阻塞状态。此时的阻塞不同于之前整个类的阻塞，而是在getInstance（）方法内部的阻塞，对于调用者的性能影响感知不强。
 在instance前添加volatile 关键字是为了解决指令重排序问题，可以参考https://blog.csdn.net/hl_java/article/details/89160086
 当然，用到synchronized关键字总归要上锁，对程序性能还是存在影响的。来看从类的初始化角度考虑的，采用静态内部类的方法实现的终极解决方案：

/**
 * @Author: zhouzhen
 * @email： zhouzhen0517@foxmail.com
 * @Description
 * @Date: Create in 23:08 2020/4/12
 */
public class LazyInnerClassSingleton {
    //使用LazyInnerClassGeneral的时候，默认会先初始化内部类
    //如果没有被使用，则内部类是不被加载的
    private LazyInnerClassSingleton() {
    }

    //static保证了单例的空间共享，final保证这个方法不会被重写和重载
    public static final LazyInnerClassSingleton getInstance() {
        //在返回结果之前，一定会先加载内部类
        return LazyHolder.LAZY;
    }

    //默认不加载
    private static class LazyHolder {
        private static final LazyInnerClassSingleton LAZY = new LazyInnerClassSingleton();
    }
}

 静态内部类在ClassPath下的形式是LazyInnerClassSingleton$LazyHolder.class的形式，LazyInnerClassSingleton类加载时不会第一时间扫描内部类，只有在getInstance()方法被调用时，内部类才会初始化，然后生成实例。这种方式兼顾了懒汉式单例模式的内存浪费问题和synchronized的性能问题，巧妙的避免了线程安全问题。

文章参考

《Spring5核心原理》〔中〕谭勇德（Tom）