单例模式

参考文章：

单例/单体模式(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;     
   }    
}