单例模式

参考文章：

单例/单体模式(Singleton)

单例模式的七种写法

一、什么是单例

单例模式是对象的创建模式之一，此外还包括工厂模式。单例模式是Javascript最基本，最有用的模式之一。它提供了一种将代码组织为一个逻辑单元的手段，这个逻辑单元中的代码通过单一的变量进行访问。

二、单例模式的三个特点：

1、该类只有一个实例
2、该类自行创建该实例(在该类内部创建自身的实例对象)
3、向整个系统公开这个实例接口

三、使用技巧

1、对于资源密集，配置开销较大的单体更合理的做法是将实例化(new)推迟到使用它的时候，即惰性加载(Lazy loading)。它常用于那些必须加载大量数据的单体，直到需要使用它的时候才实例化。

2、对于MonoBehaviour派生类的单例，如果使用“new”关键字来创建实例时，必须要绑定gameObject对象，以免报错空引用。

3、最好加上私有构造方法，防止外部类直接new出单例的实例。

四、五种写法（Java）

1、懒汉

（1）最常见，惰性加载最明显，但在多线程时不能正常工作，线程不安全。

public class Singleton {      private static Singleton instance;      private Singleton (){}        public static Singleton getInstance() {      if (instance == null) {          instance = new Singleton();      }      return instance;      }  }  

（2）使用同步改进，可以兼顾线程安全，但由于99%情况下不需要同步，导致效率低下。

public class Singleton {      private static Singleton instance;      private Singleton (){}      public static synchronized Singleton getInstance() {      if (instance == null) {          instance = new Singleton();      }      return instance;      }  }  

2、饿汉

（1）基于classloder机制避免了多线程的同步问题。不过，虽然导致类装载的原因有很多种，在单例模式中大多数都是调用getInstance方法， 但是也不能确定有其他的方式（或者其他的静态方法）导致类装载，instance在类装载时就实例化，没有了惰性加载的效果。

public class Singleton {      private static Singleton instance = new Singleton();      private Singleton (){}      public static Singleton getInstance() {      return instance;      }  } 

3、静态内部类

（1）同样利用了classloder的机制来保证初始化instance时只有一个线程，相对于饿汉写法来说，惰性加载很明显，因为SingletonHolder类没有被主动使用，只有显示通过调用getInstance方法时，才会显式装载SingletonHolder类，从而实例化instance。

public class Singleton {      /**       * 类级的内部类，也就是静态的成员式内部类，该内部类的实例与外部类的实例      * 没有绑定关系，而且只有被调用到才会装载，从而实现了延迟加载       */         private static class SingletonHolder {      /**       * 静态初始化器，由JVM来保证线程安全       */      private static final Singleton INSTANCE = new Singleton();      }    /**       * 私有化构造方法       */        private Singleton (){}      public static final Singleton getInstance() {      return SingletonHolder.INSTANCE;      }  } 

4、枚举

（1）这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。由于1.5中才加入enum特性，声明为枚举后，jvm保证枚举的实例为单例，而且枚举里面的视为静态常量。用这种方式写不免让人感觉生疏。

public enum Singleton {      INSTANCE;      public void whateverMethod() {      }  }  

5、双重校验锁

（1）属于懒汉线程同步的升级版。在JDK1.5之后，双重检查锁定才能够正常达到单例效果。由于jdk1.5的里程碑版本引入了修饰符volatile，这种写法变得很有意义且被广泛使用。

public class Singleton {      private volatile static Singleton singleton;      private Singleton (){}      public static Singleton getSingleton() {      if (singleton == null) {          synchronized (Singleton.class) {          if (singleton == null) {              singleton = new Singleton();          }          }      }      return singleton;  //（评论说这句应该是在synchronized中返回）    }  }  

6、利用JVM的类加载机制

（1）它是线程安全的，同时又是在用到的时候才会创建（利用了java虚拟机的类加载特性）

public class ManagerHolder {      public static Manager managerHolder = new Manager();  }    public class Manager {      public static Manager getInstances() {          return ManagerHolder.managerHolder;      }  } 

7、针对两个问题的改进写法

（1）如果单例由不同的类装载器装入，那便有可能存在多个单例类的实例。假定不是远端存取，例如一些servlet容器对每个servlet使用完全不同的类装载器，这样的话如果有两个servlet访问一个单例类，它们就都会有各自的实例。改进为：（详细用法呢？）

private static Class getClass(String classname)                                               throws ClassNotFoundException {           ClassLoader classLoader = Thread.currentThread().getContextClassLoader();                 if(classLoader == null)              classLoader = Singleton.class.getClassLoader();                 return (classLoader.loadClass(classname));        }     }  

（2）如果Singleton实现了java.io.Serializable接口，那么这个类的实例就可能被序列化和复原。不管怎样，如果你序列化一个单例类的对象，接下来复原多个那个对象，那你就会有多个单例类的实例。改进为：

public class Singleton implements java.io.Serializable {        public static Singleton INSTANCE = new Singleton();              protected Singleton() {        }        private Object readResolve() {             return INSTANCE;        }    }