单例模式的七种写法

看了一篇文章说到单例模式一共有七种写法，但自己还不完全懂，就百度了一下。

第一种饿汉模式

public class Singleton {

        private static Singleton instance = new Singleton();

        private Singleton(){

        }

       public static Singleton getInstance(){

              return instanace;

      }

}

这种方式在类加载时就完成了初始化，所以类加载较慢，但获取对象的速度快。

第二种懒汉模式（线程不安全）

public class Singleton{

        private static Singleton instance;

        private Singleton(){

         }

        public static Singleton getInstance(){

              if ( instance == null){

                      instnace = new Singleton();

             }

            return instance;

       }

}

懒汉模式声明了一个静态对象，在用户第一次调用时初始化，虽然节约了资源，但第一次加载时需要实例化，反应稍慢一些，而且在多线程不能正常工作。

第三种懒汉模式（线程安全）

public class Singleton{

        private static Singleton instance;

        private Singleton(){

        }

        public static synchronized Singleton getInstance(){

                   if (instance == null){

                         instance = new Singleton();

                  } 

           return instance;

       }

}

这种写法能够在多线程中很好的工作，但是每次调用getInstance方法时都需要进行同步，造成不必要的同步开销，而且大部分时候我们用不到同步的，所以不建议用这种模式。

第四种双重检查模式（DCL）

public class Singleton{

          private volatile static Singleton singleton;

          private static Singleton(){

          }

         public static Singleton getInstance(){

               if(instance == null){

                    synchronized (Singleton.class){

                     if(instance == null){

                           instance = new Singleton();

                    }

                  }

               }

         }

}

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是在singleton等于null的情况下才创建实例。在这里用到了volatile关键字，不了解volatile关键字的可以查看Java多线程（三）volatile域这篇文章，在这篇文章我也提到了双重检查模式是正确使用volatile关键字的场景之一。

在这里使用volatile会或多或少的影响性能，但考虑到程序的正确性，牺牲这点性能还是值得的。 DCL优点是资源利用率高，第一次执行getInstance时单例对象才被实例化，效率高。缺点是第一次加载时反应稍慢一些，在高并发环境下也有一定的缺陷，虽然发生的概率很小。DCL虽然在一定程度解决了资源的消耗和多余的同步，线程安全等问题，但是他还是在某些情况会出现失效的问题，也就是DCL失效，在《java并发编程实践》一书建议用静态内部类单例模式来替代DCL。

第五种静态内部类单例模式

public class Singleton{

     private Singleton(){

      }

      public static Singleton getInstance(){

           return SingletonHolder.sInstance;

     }

     private static class SingletonHolder{

           private static final Singleton sInstance = new Singleton();

      }

}

第一次加载Singleton类时并不会初始化sInstance，只有第一次调用getInstance方法时虚拟机加载SingletonHolder 并初始化sInstance ，这样不仅能确保线程安全也能保证Singleton类的唯一性，所以推荐使用静态内部类单例模式。

第六种枚举单例

public enum Singleton{

     INSTANCE;

     public void doSomeThing(){

      }

}

默认枚举实例的创建是线程安全的，并且在任何情况下都是单例，上述讲的几种单例模式实现中，有一种情况下他们会重新创建对象，那就是反序列化，将一个单例实例对象写到磁盘再读回来，从而获得了一个实例。反序列化操作提供了readResolve方法，这个方法可以让开发人员控制对象的反序列化。在上述的几个方法示例中如果要杜绝单例对象被反序列化是重新生成对象，就必须加入如下方法：

private Object readResolve() throws ObjectStreamException{

     return singleton;

}

枚举单例的优点就是简单，但是大部分应用开发很少用枚举，可读性并不是很高，不建议用。

第七种使用容器实现单例模式

public class SingletonManager{

      private static Map<String,Object> objMap = new HashMap<String,Object>();

      private Singleton(){

      }

    public static void registerService (String key,Object instance){

          if(!objMap.containsKey(key)){

                objMap.put(key,instance);

            }

      }

   public static ObjectgetService(String key){

         return objMap.get(key);

  }

}