单例模式的三种实现方式

1.赖汉式

顾名思义，当我需要某个类时，才去判断它是否存在，不存在才创建，存在则直接返回。

代码实现：代码比较简单，就不写注释了。

/**
 * @filename LHan
 * @description 赖汉模式
 * @date 2020/12/24 13:57
 */
public class LHan {
	private static LHan han;

	private LHan(){}

	public static LHan getLHan(){
		if (han == null){
			return new LHan();
		}
		return han;
	}

}

2.饿汉式

顾名思义，当我需要用到某个类时，不管这个类的实例有没有有被创建，我都会自己创建一个新的实例并返回。

代码实现：

package com.market.design.single;

/**
 * @filename EHan
 * @description 饿汉试
 * @date 2020/12/24 14:38
 */
public class EHan {
	private static EHan instance = new EHan();

	private EHan(){}

	public static EHan getInstance(){
		return instance;
	}
}

3.双重校验锁（DCL）

赖汉模式在单线程下很够很好的保证只创建一个对象，但是在多线程高并发下却可能造成创建多个对象（非线程安全），至于为什么非线程安全百度一搜一大堆，我就不重复说了，现在主要是实现双重校验锁。

package com.market.design.single;

/**
 * @filename DoubleCheck
 * @description 双重校验锁（DCL）
 * @author 单例模式
 * @date 2020/12/23 17:16
 */
public class DoubleCheck {
	private static volatile DoubleCheck doubleCheck;

	private DoubleCheck(){}

	public static DoubleCheck getDoubleCheck(){
		if (doubleCheck == null){   //先判断对象是否为null
			synchronized (DoubleCheck.class){ //加锁
				if (doubleCheck == null){  // 加锁情况下再次判断对象是否被创建
					doubleCheck = new DoubleCheck(); //加锁情况下创建对象
				}
			}
		}
		return doubleCheck;
	}
}

补充：我在定义DoubleCheck 对象时加了volatile关键字，在多线程高并发的情况下这个关键字必须加上，因为它在这里起到的最大的作用就是防止指令重排序，至于原理，请大家去b站搜一下马士兵老师视频，关键字volatile，讲的很透彻，大概两个小时左右。