单例模式

1、饿汉式（最简单适用）

类加载到内存中，就实例化一个单例，JVM保证线程安全；
简单适用，推荐使用；
唯一缺点，不管用到与否，类加载时就完成实例化；
（话说你不用的，你加载它干嘛）

public class Mgr01{
	private static final Mgr01 INSTANCE = new Mgr01();
	
	private Mgr01(){};
	
	`public static Mgr01 getInstance(){
		return INSTANCE ;
	}
	public static void main(String[] args){
		Mgr01 m1 = Mgr01.getInstance();
		Mgr01 m2 = Mgr01.getInstance();
		System.out.println(m1 == m2);
	}
}

打印结果 ： true

2、懒汉式

虽然达到了需要用才初始化的目的，但带来了线程的不安全

public class Mgr02{
	private static Mgr02 INSTANCE ;
	
	private Mgr02(){};
	
	public static Mgr02 getInstance(){
		if(INSTANCE = null){
			INSTANCE  = new Mgr02();
		}
		return INSTANCE ;
	}
	public static void main(String[] args){
		for(int i = 0 ;i<100 ;i++){
			new Thread(()->{
				System.out.prinln(Mgr02.getInstance.hashCode());
			}).start();
		}
	}
}

3、lazy loading (也称懒汉式)

虽然达到了需要用才初始化的目的，但带来了线程的不安全；
可以通过synchronized 来解决不安全问题，锁定了当前对象，但也带来了效率的下降

public class Mgr03{
	private static Mgr03 INSTANCE ;
	
	private Mgr03(){};
	
	public static synchronized Mgr03 getInstance(){   //锁定了Mgr03 的class对象
		if(INSTANCE = null){
			INSTANCE  = new Mgr03();
		}
		return INSTANCE ;
	}
	public static void main(String[] args){
		for(int i = 0 ;i<100 ;i++){
			new Thread(()->{
				System.out.prinln(Mgr03.getInstance.hashCode());
			}).start();
		}
	}
}

4、静态的内部类方式

JVM保证单例
加载外部类时不会加载内部类，这样可以实现懒加载

public class Mgr04{
	private Mgr04(){};
	//Mgr04的持有者，在静态内部类里面初始化实例对象
	public static class Mgr04Holder(){   
		private static final Mgr04 INSTANCE = new Mgr04();
	}
	
	public static Mgr04 getInstance(){ 
		return Mgr04Holder.INSTANCE ;
	}
	
	public static void main(String[] args){
		for(int i = 0 ;i<100 ;i++){
			new Thread(()->{
				System.out.prinln(Mgr04.getInstance.hashCode());
			}).start();
		}
	}
}