单例模式是设计模式中最常用到的一种模式,一般应用于定位管理、线程管理、文件管理、网络管理等类上面，让这些类的单一实例来处理App的各个模块逻辑等。
这里我就不多举例子了，相信大家应该都会用，我就将基本所有类型的单例实现方式列举出来，供大家参考吧。
（1）几种常见的单例模式模板
- 饿汉单例
“饿汉”，指的是代码很早就想要初始化实例出来，于是，此形式的类实例在类编译加载在内存中的时候就初始化创建完毕。
public class Singleton{
private static Singleton sInstance = new SingleTon();
private Singleton() {}
public Singleton getInstance(){
return sInstance;
}
}
优点：类加载时实例化对象，避免了多线程同步创建问题。
缺点：类加载时就进行初始化，即还没用到它，它就占了App进程的部分内存，造成一定的内存浪费。【没有懒加载】
- 懒汉单例（加了
synchronized，保证线程安全）
“懒汉”，相对于“饿汉”来说，就不是在编译时急着初始化了，而是在调用到类静态方法要用到一个实例时，他再初始化单例对象。
public class LazySingleTon {
private static LazySingleTon sInstance;
private LazySingleTon(){
}
public static synchronized LazySingleTon getInstance(){
if(sInstance==null){
sInstance = new LazySingleTon();
}
return sInstance;
}
}
注意，以上的code，方法加synchronized与否，直接影响读取性能。
- DCL 单例（双重检查锁定）
public class DCLSingleTon {
// private static DCLSingleTon sInstance;
private volatile static DCLSingleTon sInstance = null;
///考虑到 DCL失效问题：JDK1.5之前的JMM（Java内存模型）中的Cache、寄存器到主内存回写顺序的规定，上面三件事中的后面两件事的顺序无法保证。
///这样，如果是执行1->3->2的执行顺序，那么，在内部成员都没有被初始化的情况下，sInstance就已经被赋值为非null了，那就后面会产生错误了。
///于是，>=JDK1.5时，可以这样：
// private volatile static DCLSingleTon sInstance = null;
///虽然这样，加载时会影响性能，但是，还是值得的。
///这样一来，就可以每次在主内存中读取对象了。
private DCLSingleTon(){
}
public static DCLSingleTon getInstance(){
if(sInstance== null){
synchronized (DCLSingleTon.class) {
if(sInstance == null){
sInstance = new DCLSingleTon();
}
}
}
return sInstance;
}
}
- 优点：既能够在需要时才初始化单例【懒加载】，又能够保证线程安全，而且，单例对象初始化后的getInstance调用是不会进行同步锁的【第一次要初始化对象所以慢，第二次之后就很快】。
- 缺点：加入了
volatile关键字（JDK1.5以上），保证Java编译器执行顺序，但影响了性能。【不过，这个影响很小】
- 静态内部类单例【推荐】
public class StaticSingleTon {
private static StaticSingleTon sInstance;
private StaticSingleTon(){}
public static StaticSingleTon getInstance(){
return StaticSingleTon.sInstance;
}
/// 静态内部类
private static class SingleTonHolder{
private static final StaticSingleTon sInstance = new StaticSingleTon();
}
}
- 特点：同样 是 只有第一次调用
getInstance()时，才会加载SingleTonHolder类，也才会初始化对象。 - 解决了DCL乱序问题【不怕他会执行乱序。一定是先初始化对象，然后获取对象。】
- 枚举单例
public enum EnumSingleTon {
DOG,CAT;
public void bark(){
System.out.println(toString()+"吠了一声！");
}
}
然后，我们可以直接调用:
DOG.bark();
DOG.bark();
CAT.bark();
CAT.bark();
永远只存在一条狗和一只猫的实例。
- 优点：解决了对象反序列化问题（任何时候都是单例）
- 什么是“反序列化问题”？ 答：就是，即使你的单例类的构造器是
private的，但是到反序列化那一步的时候，依然会通过特殊手段去调用该方法，来实例化一个新的实例。【so，将对象写入磁盘，再读取出来的过程，就会新建对象，而不是用回原来的实例。】
- 使用容器
使用容器，同样能实现单例模式。
public class SingleTonManager {
private static Map<String, Object> objMap = new HashMap<String,Object>();
private SingleTonManager(){}
public static void registerService(String key , Object instance){
if(! objMap.containsKey(key)){
objMap.put(key, instance);
}
}
public static Object getInstance(String key){
return objMap.get(key);
}
}
