单例设计模式的几种实现方法

​​​​​​1，饿汉式

1.1 直接实例化饿汉式

/**
 * 饿汉式：直接创建对象，不存在线程安全问题
 * @author lais
 *
 */
public class EHanSingle {

	//私有化构造器
	private EHanSingle(){}
	
	//私有化静态对象，并直接创建，强调单例时可以用final修饰
	private final static EHanSingle single = new EHanSingle();
	
	//提供外界获取方式
	public static EHanSingle getInstance(){
		return single;
	}
	//测试
	public static void main(String[] args) {
		EHanSingle instance1 = EHanSingle.getInstance();
		EHanSingle instance2 = EHanSingle.getInstance();
		System.out.println(instance1);
		System.out.println(instance2);
	}
}

1.2 枚举式饿汉式

/**
 * 枚举类饿汉式
 * 枚举类型：表示该对象是有限的几个，我们限定为一个，就是单例了
 * @author lais
 *
 */
public enum EHanEnum {
	//实例对象
	INSTANCE;
	
	//测试方法
	public static void main(String[] args) { 
		System.out.println(EHanEnum.INSTANCE);
		System.out.println(EHanEnum.INSTANCE);
	}
}

1.3 静态代码块饿汉式

/**
 * 静态代码块饿汉式：使用与复杂场景
 * @author lais
 *
 */
public class EHanSingle2 {

	//私有化构造器
	private EHanSingle2(){}
	
	//私有化静态对象，并直接创建
	private static final  EHanSingle2 single ;
	
	static {
		//可以在初始化对象之前进行某些初始化操作
		//例如，从外界配置文件中加载某些属性数据等
		single = new EHanSingle2();
	}
	//提供外界获取方式 
	public static EHanSingle2 getInstance(){
		return single;
	}
	//测试
	public static void main(String[] args) {
		EHanSingle2 instance1 = EHanSingle2.getInstance();
		EHanSingle2 instance2 = EHanSingle2.getInstance();
		System.out.println(instance1);
		System.out.println(instance2);
	}
}

2、懒汉式

2.1、  线程不安全的懒汉式

/**
 * 懒汉式：懒汉式存在线程安全问题
 * @author lais
 *
 */
public class LanHanSingle {
	
	private LanHanSingle(){}
	
	private static LanHanSingle single;
	
	public static LanHanSingle getInstance(){
		//可以加些判断要求
		single = new LanHanSingle();
		return single;
	}
}

2.2 线程安全的懒汉式

/**
 * 懒汉式：懒汉式存在线程安全问题
 * @author lais
 *
 */
public class LanHanSingle2 {
	
	private LanHanSingle2(){}
	
	private static LanHanSingle2 single;
	
	public static LanHanSingle2 getInstance(){
		//可以加些判断要求
		if(single == null){
			synchronized (LanHanSingle2.class) {
				if(single == null)
					single = new LanHanSingle2();
			}
		}
		return single;
	}
}

2.3 静态内部类懒汉式

/**
 * 在内部类被加载和初始化时，才创建INSTANCE实例对象
 * 静态内部类不会自动随着外部类的加载和初始化而初始化，它是单独去加载和初始化的
 * 因为是在内部类加载和初始化时，创建的，因此时线程安全的
 * @author lais
 *
 */
public class InnerSingle {

	private InnerSingle(){}
	
	private static class Inner{
		private static final InnerSingle INSTANCE = new InnerSingle();
	}
	
	public static InnerSingle getInstance(){
		return Inner.INSTANCE;
	}
}

3，总结

使用饿汉式时，枚举方式最简单

使用懒汉式时，静态内部类方式最简单