单例模式狂风的博客-

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(); } } }