【设计模式】各个击破单例模式的8种写法
单例模式
在一个系统开发过程中，我们在基于节省内存资源、保证数据内容的一致性的考虑上，往往需要对某些类要求只能创建一个实例，即「保证类只有一个实例」的设计模式就是单例模式。
比如我们遇到过的各种Manager管理类，各种Factory工厂类；
Spring 框架应用中的 ApplicationContext、数据库中的连接池等也都是单例模式。
本文旨在浅析一下单例模式的写法。
单例模式的8种写法
1. 饿汉式
/**
* 类加载的时候就实例化一个实例，JVM保证线程安全
* 也称饿汉式
* 该方式简单实用
* @author 行百里er
*/
public class Singleton_1 {
private static final Singleton_1 INSTANCE = new Singleton_1();
/**
* 私有的构造方法，其他地方不能new
*/
private Singleton_1() {
}
public static Singleton_1 getInstance() {
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
Singleton_1 instance1 = Singleton_1.getInstance();
Singleton_1 instance2 = Singleton_1.getInstance();
System.out.println(instance1 == instance2);
}
}
这是我推荐使用的方法，简单实用，写着安心，用着放心。
2. 意思同第一种，只是写法不同
/**
* 和Singleton_1是同一个意思
* 只是将new的动作放在了代码块里
* 类加载到内存的时候只加载一个实例
* @author 行百里er
*/
public class Singleton_2 {
private static final Singleton_2 INSTANCE;
static {
INSTANCE = new Singleton_2();
}
/**
* 私有的构造方法，其他地方不能new
*/
private Singleton_2() {
}
public static Singleton_2 getInstance() {
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
Singleton_2 instance1 = Singleton_2.getInstance();
Singleton_2 instance2 = Singleton_2.getInstance();
System.out.println(instance1 == instance2);
}
}
和第一种写法是同一个意思，只是将new的动作放在了代码块里，类加载到内存的时候只加载一个实例。
3. 懒汉式，用到的时候才实例化
/**
* 懒汉式
* 这种写法虽然达到了用的时候才初始化的目的，但是存在多线程获取实例时相互影响的问题
* @author 行百里er
*/
public class Singleton_3 {
private static Singleton_3 INSTANCE;
/**
* 私有的构造方法，其他地方不能new
*/
private Singleton_3() {
}
public static Singleton_3 getInstance() {
if (INSTANCE == null) {
// sleep一下，测试
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_3();
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程，看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_3.getInstance().hashCode())).start();
}
}
}
这种写法虽然达到了用的时候才初始化的目的，但是「存在多线程获取实例时相互影响」的问题。
运行结果：
4. 在上一种写法的基础上加synchronized锁，保证线程安全
/**
* lazy loading 懒汉式
*
* 可以用synchronized加锁，但是效率会降低
* @author 行百里er
*/
public class Singleton_4 {
private static Singleton_4 INSTANCE;
/**
* 私有的构造方法，其他地方不能new
*/
private Singleton_4() {
}
/**
* 既然lazy loading的写法有线程安全问题，那就加把锁
*/
public static synchronized Singleton_4 getInstance() {
if (INSTANCE == null) {
// 测试，sleep一下，增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_4();
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程，看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_4.getInstance().hashCode())).start();
}
}
}
这种方式可行，但会带来效率下降的问题。下面继续“吹毛求疵”。
5. 那就在线程安全的基础上减少锁住的代码数量，「这里有坑」
/**
* lazy loading 懒汉式
* 在加锁的基础上再优化一下，减少加锁代码块的数量
* @author 行百里er
*/
public class Singleton_5 {
private static Singleton_5 INSTANCE;
/**
* 私有的构造方法，其他地方不能new
*/
private Singleton_5() {
}
public static Singleton_5 getInstance() {
if (INSTANCE == null) {
//不在方法上加锁而在new的时候才加锁，减少锁的代码，然而这种方式并不行
synchronized (Singleton_5.class) {
// 测试，sleep一下，增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_5();
}
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程，看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_5.getInstance().hashCode())).start();
}
}
}
先看运行结果：
说明这种写法看似在线程安全有减少了锁的代码量，其实是达不到“永远”单例的目的的。
「原因分析」：线程A运行完if(INSTANCE == null)，还没拿到锁时候，线程B也运行到if(INSTANCE == null)这一句并且拿到锁进行了new实例化，然后线程B释放锁，线程A得到锁继续运行if语句块里面的内容进行new的过程，这样就出现了不同的实例了。
6. 那就来个双重检查锁（Double Check Locking）吧
/**
* 在加锁的基础上再优化一下，减少加锁代码块的数量---事实证明不可行
* 那就双重检查DCL
* @author 行百里er
*/
public class Singleton_6 {
private static Singleton_6 INSTANCE;
/**
* 私有的构造方法，其他地方不能new
*/
private Singleton_6() {
}
public static Singleton_6 getInstance() {
if (INSTANCE == null) { //第一重检查
synchronized (Singleton_6.class) {
if (INSTANCE == null) { //第二重检查
// 测试，sleep一下，增加被其他线程打断的机会
try {
Thread.sleep(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
INSTANCE = new Singleton_6();
}
}
}
return INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程，看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_6.getInstance().hashCode())).start();
}
}
}
这里，提个问题：「INSTANCE要不要加volatile」？
答案是肯定的。
「volatile」的作用是「保证线程可见性和禁止指令重排序」。在DCL单利模式写法中，volatile主要是用于禁止指令重排序的。因为如果不加volatile关键字，那么可能会出现指令重排序。
假设：一个线程A执行到 「INSTANCE = new Singleton_6()」 的时候，经过编译器编译，会分成三个指令（注意 INSTANCE 是static的）：
给指令申请内存
给成员变量初始化
把这块内存的内容赋值给INSTANCE
既然有值了，那么线程B上来先进行检查发现已经有值，就不会进入加锁那部分的代码了。
加了「volatile」后，就不允许指令重排序了。所以此时一定是保证线程A初始化完了才会复制给这个变量。
7. 静态内部类方式
/**
* 静态内部类方式
* JVM保证单例
* 加载外部类时不会加载内部类---也可实现懒加载
* @author 行百里er
*/
public class Singleton_7 {
/**
* 私有的构造方法，其他地方不能new
*/
private Singleton_7() {
}
private static class SingletonHolder {
private static final Singleton_7 INSTANCE = new Singleton_7();
}
public static Singleton_7 getInstance() {
return SingletonHolder.INSTANCE;
}
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程，看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_7.getInstance().hashCode())).start();
}
}
}
即可保证单例（虚拟机保证），也能实现懒加载。
如果非要追求完美，那么可以用这种方式。
8. 完美中的完美方式，Enum实现单例
/**
* 枚举单例
* 不仅可以解决线程同步，还可以防止反序列化
*/
public enum Singleton_8 {
INSTANCE;
/**
* for test
*/
public static void main(String[] args) {
//同一个类的不同对象的hashcode不同
//跑100个线程，看看有没有不同的实例
for (int i = 0; i < 100; i++) {
new Thread(() -> System.out.println(Singleton_8.INSTANCE.hashCode())).start();
}
}
}
膜拜一波这种写法！这是Java创始人之一的大神在《Effective Java》这本书中推荐的写法。
小结
虽然单例模式有这么多种写法，但不少是炫技式的花活，有点像孔乙己的“茴”字的N中写法。
这里我们理解其中有些写法的“瑕疵”和其中蕴含的“原理”就可以了。
有道无术，术可成；有术无道，止于术
好文章，我在看❤️