概述
单例模式（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）
