单例模式：保证一个类只有一个实例，并提供全局的一个访问对象

    优点：
    节省系统资源，不用频繁创建对象
    资源共享，使用同一个实例，不会存在信息不匹配

    实现：
    1、饿加载（饿汉模式）
    即在系统初始化时，便生成对象，线程安全

    1. /**
    2.  * 饿加载单例
    3.  */
    4. public class HungrySingle {
    5.     private static HungrySingle hungrySingle = new HungrySingle();
    7.     public static HungrySingle getHungrySingle(){
    8.         return hungrySingle;
    9.     }
    11.     private HungrySingle(){
    12.     }
    13. }

    2、懒加载（懒汉模式）
    即系统初始化时不生成对象，使用对象时，才生成对象，线程不安全（当线程A判断对象null时，会去创建对象，这时线程B访问，对象还未创建，线程B会再去创建对象，所以懒加载是线程不安全的）

    1. /**
    2.  * 懒加载单例
    3.  */
    4. public class LazyLoadingSingle {
    5.     private static LazyLoadingSingle lazyLoadingSingle;
    7.     public static LazyLoadingSingle getLazyLoadingSingle(){
    8.         if (lazyLoadingSingle == null){
    9.             lazyLoadingSingle = new LazyLoadingSingle();
    10.         }
    11.         return lazyLoadingSingle;
    12.     }
    14.     private LazyLoadingSingle(){
    15.     }
    16. }

    3、枚举创建
    枚举创建也是线程安全的，这个方法其实是用到了枚举构造方法只会执行一次的特性

    1. /**
    2.  * 枚举单例
    3.  */
    4. public class EnumSingle {
    6.     public static EnumSingle getEnumSingle(){
    7.         return DemoSingleEnum.INSTANCE.enumSingle;
    8.     }
    10.     private enum DemoSingleEnum{
    11.         INSTANCE;
    12.         private EnumSingle enumSingle;
    14.         public EnumSingle getEnumSingle(){
    15.             return enumSingle;
    16.         }
    18.         DemoSingleEnum(){
    19.             enumSingle = new EnumSingle();
    20.         }
    21.     }
    23.     private EnumSingle(){
    24.     }
    25. }

    最后测试结果，不管方法调用几次，获取到的都是同一个对象
    image.png