『手撕』单例模式

1.饿汉模式：指全局的单例实例在类装载时构建。

class HungryWay{
    //在静态初始化器中创建单例实例，这段代码保证了线程安全
     private  static   HungryWay  uniqueInstance=new HungryWay();
    //Singleton类只有一个构造方法并且是被private修饰的，所以用户无法通过new方法创建该对象实例
    private HungryWay(){}
    public static  HungryWay getInstance(){
        return uniqueInstance;
    }
}

2.懒汉方式：指全局的单例实例在第一次被使用时构建。
“ 懒汉式” 就是说单例实例在第一次被使用时构建，而不是在JVM在加载这个类时就马上创建此唯一的单例实例。

class LazyWay{
    private  static  LazyWay uniqueInstance;
    private  LazyWay(){}
    //没有加入synchronized关键字的版本是线程不安全的
    public static synchronized LazyWay  getInstance(){
        //判断当前单例是否已经存在，若存在则返回，不存在则再建立单例
        if(uniqueInstance==null){
            uniqueInstance=new LazyWay();
        }
        return  uniqueInstance;
    }
}

3.懒汉式(双重检查加锁版本)

class  DoubleCheck{
        //volatile保证，当doubleCheck变量被初始化成doubleCheck实例时，
        //多个线程可以正确处理doubleCheck变量
      private volatile   static  DoubleCheck doubleCheck;
      private  DoubleCheck(){}
      public static  DoubleCheck   getInstance(){
          if(doubleCheck==null){
              synchronized (DoubleCheck.class){
                  //进入同步代码块后，再检查一次，如果仍是null，才创建实例
                  if(doubleCheck==null){
                      doubleCheck=new DoubleCheck();
                  }
              }
          }
          return doubleCheck;
      }
    }

4.饿汉式（枚举方式）
一般推荐使用这种。

 enum  Singleton {
         //定义一个枚举的元素，它就是 Singleton 的一个实例
         INSTANCE;

         public void get(){
             System.out.println("枚举实现单例模式");
         }
     }

5.懒汉式（登记式/静态内部类方式）
静态内部实现的单例是懒加载的且线程安全。

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

看完觉得可以的小伙伴可以顺手点个赞嘛，谢谢。