单例模式常见的几种写法

一、单例模式的定义
确保这个类在内存中只会存在一个对象,而且自行实例化并向整个应用系统提供这个实例。
二、单例模式的应用场景
一般创建一个对象需要消耗过多的资源,如:访问I0和数据库等资源或者有很多个地方都用到了这个实例。
三、单例模式的几种基本写法:

饿汉式
public class Singleton {
    private static final Singleton INSTANCE=new Singleton();
    private Singleton(){}
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期 都存在。它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。
缺点：不需要的时候就加载了，造成资源浪费。

懒汉式
  public class Singleton{  
      private static Singleton instance = null;  
      private Singleton(){}  
      public static Singleton newInstance(){  
          if(null == instance){  
              instance = new Singleton();  
          }  
          return instance;  
      }  
  }

懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择。但是这里的懒汉模式并没有考虑线程安全问题，在多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，因此需要加锁解决线程同步问题，实现如下。
  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 static Singleton instance;
      private Singleton(){}
      public static Singleton getInstance(){
          if(instance == null){
              synchronized (Singleton.class){
                  if(instance == null){
                      instance = new Singleton();
                  }
              }
          }
          return instance;
      }
  }

优点：资源利用率高，第一次执行方法是单例对象才会被实例化。
缺点：第一次加载时会稍慢，jdk1.5之之前有可能会加载会失败。
这种写法估计是我们在开发中最常用的，这次代码的亮点是是在getInstance()方法中进行了双重的判断，第一层判断的主要避免了不必要的同步，第二层判断是为了在null的情况下再去创建实例；举个简单的列子：假如现在有多个线程同时触发这个方法: 线程A执行到nstance = new Singleton(),它大致的做了三件事:
(1)、给Singleton实例分配内存，将函数压栈，并且申明变量类型。
(2)、初始化构造函数以及里面的字段，在堆内存开辟空间。
(3)、将instance对象指向分配的内存空间。
这种写法也并不是保证完全100%的可靠，由于java编译器允许执行无序，并且jdk1.5之前的jvm（java内存模型）中的Cache，寄存器到主内存的回写顺序规定,第二个和第三个执行是无法保证按顺序执行的，也就是说有可能1-2-3也有可能是1-3-2; 这时假如有A和B两条线程，A线程执行到3的步骤，但是未执行2,这时候B线程来了抢了权限，直接取走instance这时候就有可能报错。
简单总结就是说jdk1.5之前会造成两个问题

1、线程间共享变量不可见性。
2、无序性(执行顺序无法保证)。
当然这个bug已经修复了，SUN官方调整了JVM，具体了Volatile关键字，因此在jdk1.5之前只需要写成这样既可, private Volatitle static Singleton instance; 这样就可以保证每次都是从主内存中取,当然这样写或多或少的回影响性能，但是为了安全起见，这点性能牺牲还是值得。

Android常用的框架:Eventbus(DCL双重检查)
   static volatile EventBus defaultInstance;
      public static EventBus getDefault() {
          if (defaultInstance == null) {
              synchronized (EventBus.class) {
                  if (defaultInstance == null) {
                      defaultInstance = new EventBus();
                  }
              }
          }
          return defaultInstance;
      }

静态内部内实现单例
  public class Singleton {
      private static Singleton instance;
      private Singleton() {
      }
      public static class SingletonInstance {
          private static final Singleton INSTANCE = new Singleton();
      }
      public static Singleton getInstance() {
          return SingletonInstance.INSTANCE;
      }
  }

利用了类加载机制来保证只创建一个instance实例。它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。不一样的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。
这种方式不仅确保了线程的安全性,也能够保证对象的唯一性，同时也是延迟加载,很多技术大牛也是这样推荐书写。

枚举实现单例
  public enum SingletonEnum {
      INSTANCE;
      public void doSomething() {
      }
  }

优点：相对于其他单例来说枚举写法最简单，并且任何情况下都是单例的，JDK1.5之后才有的。

使用容器单例
  public class SingletonManager {
      private static Map<String, Object> objMap = new HashMap<>();
      private SingletonManager() {
      }
      public static void putObject(String key, String instance){
          if(!objMap.containsKey(key)){
              objMap.put(key, instance);
          }
      }
      public static Object getObject(String key){
          return objMap.get(key);
      }
  }

在开始的时候将单例类型注入到一个容器之中，也就是单例ManagerClass，在使用的时候再根据key值获取对应的实例，这种方式可以使我们很方便的管理很多单例对象，也对用户隐藏了具体实现类,降低了耦合度；但是为了避免造成内存泄漏，一般在生命周期销毁的时候也要去销毁它。

总结

一个核心原理就是私有构造,并且通过静态方法获取一个实例。
在这个过程中必须保证线程的安全性。
推荐用静态内部内实现单例或加了Volatile关键字的双重检查单例