单例模式的三种写法

设计模式类型

创造型模式

*单例模式

饿汉式 **推荐

优点：在类加载的时候就已经创建好了实例，没有线程同步的问题；

缺点：如果这个实例从始至终都没有用到，那么就会造成内存浪费；

// 方法一   使用静态对象
public class Singleton {
   // 在类加载的时候就已经创建了实例对象；
   private final static Singleton singleton= new Singleton();
   private  Singleton() {
   }
   // 提供一个静态方法返回实例对象
   public static Singleton getSingleton(){
       return singleton;
   }
}

// 方法二 使用静态代码块
public class Singleton {
   private final static Singleton singleton;
   // 静态代码块在类加载的时候执行一次，普通代码块每一次创建类都会执行
   static{
       singleton= new Singleton();
   }
       // 提供一个静态方法返回实例对象
   public static Singleton getSingleton(){
       return singleton;
   }
}

懒汉式

双重检查式

public class DoubleCheckLazy {
    private static  DoubleCheckLazy DOUBLE_CHECK_LAZY_INSTANCE = null;
    private DoubleCheckLazy(){};
    /**
     * 对外提供静态的方法
     */
    public static DoubleCheckLazy getDoubleCheckLazyInstance(){
        if (DOUBLE_CHECK_LAZY_INSTANCE == null){
            synchronized (DoubleCheckLazy.class){
                if (DOUBLE_CHECK_LAZY_INSTANCE == null){
                    DOUBLE_CHECK_LAZY_INSTANCE = new DoubleCheckLazy();
                    return DOUBLE_CHECK_LAZY_INSTANCE;
                }else {
                    return DOUBLE_CHECK_LAZY_INSTANCE;
                }
            }
        }else {
            return DOUBLE_CHECK_LAZY_INSTANCE;
        }
    }
}
// 总结  可用、但加锁、依然会出现阻塞的情况，解决了线程安全的问题。

静态内部类的方法 (利用JVM加载类的机制)

public class SingletonInnerClass {
   /**
    * 定义静态内部类、并且创建一个实例对象
    */
   private static class GetSingletonInstance{
       private static SingletonInnerClass singletonInnerClassInstance = new SingletonInnerClass();
   }

   private SingletonInnerClass(){};

   public static SingletonInnerClass getInstance(){
       return GetSingletonInstance.singletonInnerClassInstance;
   }
}

加载 SingletonInnerClass 类的时候不会去加载内部静态类，只有去调用 getInstance()的时候，才会去加载 SingletonInnerClass的静态内部类，这就达到了 Lazy加载 的效。