单例模式（Singleton）是一种非常简单且容易理解的设计模式。顾名思义，单例即单一的实例，确切地讲就是指在某个系统中只存在一个实例，同时提供集中、统一的访问接口，以使系统行为保持协调一致

1 饿汉模式  推荐写法

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:24  */ public class Test01 {     private static final Test01  INSTANCE=new Test01();      private  Test01(){      }      public static Test01 getINSTANCE() {         return INSTANCE;     }      public static void main(String[] args) {         for (int i=0;i<1000;i++){             new Thread(()->{                 System.out.println(Test01.getINSTANCE().hashCode());             }).start();         }     } } 

私有的构造方法使得Test01完全被封闭起来 实例化工作是自己内部的事务

private static final 修饰 保证了 INSTANCE是私有的 ,不可见的不可访问的,static保证了静态性,在类被加载进内存时,就已经初始化 ,final保证INSTANCE是常量,是不能被修改的

外部只要调用公共的方法TEST01.getINSTANCE就可以获得唯一的实例对象了 

2 饿汉模式 静态代码块赋值

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:24  */ public class Test03 {     private static final Test03 INSTANCE;      static {         INSTANCE=new Test03();     }     private Test03(){      }      public static Test03 getINSTANCE() {         return INSTANCE;     }      public static void main(String[] args) {         for (int i=0;i<1000;i++){             new Thread(()->{                 System.out.println(Test03.getINSTANCE().hashCode());             }).start();         }     } } 

此处将实例化操作放到静态代码块中

3 懒汉式 

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:33  */ public class Test02 {     private static Test02 test02;     private Test02(){};      public static Test02 getInstance(){         if (test02==null){             test02=new Test02();         }          return test02;     }      public static void main(String[] args) {         for (int i=0;i<1000;i++){             new Thread(()->{                 System.out.println(Test02.getInstance().hashCode());             }).start();         }     }  } 

恶汉模式如果没人使用,但是却实例化对象 ,这样一块内存区不是白浪费了 这样单杀了懒汉模式的写法

只有当某一个线程第一次调用getINSTANCE时才会进行实例化操作 之后再有线程访问直接返回对象

这样程序乍看确实没什么问题 但是在多线程环境下 可能会有多个线程进入到了getINSTANCE方法内,这样就会导致原来已经实例化的对象被覆盖掉

为了保证线程安全 我们给getINSTANCE方法加上 synchronized同步锁 下面看第四种写法

4  synchronized 版懒汉模式

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:33  */ public class Test04 {     private static Test04 test02;     private Test04(){};      public static synchronized Test04 getInstance(){         if (test02==null){             test02=new Test04();         }          return test02;     }      public static void main(String[] args) {         for (int i=0;i<1000;i++){             new Thread(()->{                 System.out.println(Test04.getInstance().hashCode());             }).start();         }     }  } 

这样确实没有什么问题 然而这样的做法是要付出一定代价的，试想，线程还没进入方法内部便不管三七二十一直接加锁排队，会造成线程阻塞，资源与时间被白白浪费。我们只是为了实例化一个单例对象而已，犯不上如此兴师动众，使用synchronized让所有请求排队等候。所以，要保证多线程并发下逻辑的正确性，同步锁一定要加得恰到好处

下面看第五种写法 在方法体内部加锁:

5  synchronized 内部加锁

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:33  */ public class Test05 {     private static Test05 test02;     private Test05(){};      public static  Test05 getInstance(){         if (test02==null){             synchronized (Test05.class){                 test02=new Test05();             }                      }          return test02;     }      public static void main(String[] args) {         for (int i=0;i<1000;i++){             new Thread(()->{                 System.out.println(Test05.getInstance().hashCode());             }).start();         }     }  } 

这样在多线程环境也会有一定问题 ,可能会有多个线程同时通过了 tese02==null 的判断进入了方法里,这样也会造成重复的实例化

6  双重检查synchronized 推荐写法

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:33  */ public class Test06 {     private static  volatile  Test06 test02;     private Test06(){};      public static Test06 getInstance(){         if (test02==null){             synchronized (Test06.class){                 if (test02==null){                     test02=new Test06();                 }             }         }          return test02;     }      public static void main(String[] args) {         for (int i=0;i<1000;i++){             new Thread(()->{                 System.out.println(Test06.getInstance().hashCode());             }).start();         }     }  } 

我们一共用了2个嵌套的判空逻辑，这就是懒加载模式的“双检锁”：外层放宽入口，保证线程并发的高效性；内层加锁同步，保证实例化的单次运行。如此里应外合，不仅达到了单例模式的效果，还完美地保证了构建过程的运行效率，一举两得。

7  内部类方式

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:51  */ public class Test07 {      private Test07(){};      private static class Test0701{         private static final  Test07 test07=new Test07();     }          public   static  Test07 getInstance(){         return Test0701.test07;     }      public static void main(String[] args) {         for (int i=0;i<1000;i++){             new Thread(()->{                 System.out.println(Test07.getInstance().hashCode());             }).start();         }     }      } 

8 枚举类方式

package com.cyc.mystudy.singleton;  /**  * @Author cyc  * @create 2022/7/30 11:57  */ public enum Test08 {      INSTANCE;      public  void m(){         System.out.println("业务代码");     }      public static void main(String[] args) {         Test08.INSTANCE.m();     } } 

在一般情况下我们使用饿汉模式,恶汉模式不用担心多线程环境会出问题,写法上也比较简单,

我们不用为了省一点性能而去给自己造成麻烦