单例模式全汇总——《Android源码设计模式解析与实战》读书笔记

导语：单例模式应该是使用最为广泛的一种模式了，以前也知道懒汉式和恶汉式，但是没有总结过，这次看到了关於单例模式的基本可能的实现方式，现在记录一下，方便以后自己可以看。

一.饿汉式

/**
 * 饿汉式单例
 * Created by 追风车的面瘫
 */
public class Singleton {

    public static final Singleton sInstance = new Singleton();

    public Singleton(){}

    public static Singleton getInstance(){

    return sInstance;
    }

}

特点：节省时间，但类创建之后就实例化了，无论使用与否，始终在内存中，线程始终是安全的。

二.懒汉式

   /**
   * 懒汉式单例

     * Created by 追风车的面瘫
 */

public class Singleton {

    private static  Singleton sInstance = null;

    public Singleton(){

    }

    public synchronized static Singleton getsInstance(){
           if(sInstance==null){
            sInstance  = new Singleton();
        }
    return sInstance;
    }
}

特点：节省了空间，在需要的时候才创建，但第一次获取时会有点慢，线程不安全。

三.双重检查锁定

/**

   *
   * 双重检查锁定单例
   * Created by 追风车的面瘫
   */
public class Singleton {
    public Singleton(){

    }

    public static Singleton getsInstance(){
        if(sInstance == null){
            synchronized (Singleton.class){
                if(sInstance == null){
                    sInstance = new Singleton();
                }
            }
        }
    return sInstance;
        }

}

特点：既能在需要时初始化，又能够保证线程安全，且单例对象初始化后调用getInstance()不进行同步锁。
但是考虑到Java并发过程中，Java编译器允许处理器乱序执行，有可能会有bug,造成空指针的错误，但JDK1.5开始，官方具体化了volatile关键字，可以解决这个问题,只需改一句代码：

//volatile修饰后，更安全
private volatile static Singleton sInstance =null;

关于volatile关键字，可查看http://www.cnblogs.com/dolphin0520/p/3920373.html，讲的非常清楚。

四.静态内部类

/**
 * 静态内部类实现单例    推荐
 * Created by 追风车的面瘫
 */

public class Singleton {

    public Singleton(){

    }

        public static Singleton getInstance(){
        return SingletonHolder.sInstance;
    }

    /**
     * 静态内部类
     */
    private static class SingletonHolder{
        private static final Singleton sInstance = new Singleton();
    }

}

特点：线程安全，也保证了对象唯一性。

五.枚举单例

   /**
   *枚举单例
*Created by 追风车的面瘫
*/

public enum  Singleton {

    INSTANCE;

    public  void doSomething(){
        System.out.println("do sth.");
    }
}

特点：写法简单，默认线程就是安全的。相比以上几个方式，有一个优点，即使反序列化也不会重新生成新的实例。

六.使用容器实现单例模式

   /**

 * Created by 追风车的面瘫
 */
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 getService(String key){
        return objMap.get(key);
    }

}

特点：程序初始时，将多种单例类型注入到一个统一的管理类，使用时根据key获取，可以管理多种单例。比如android源码中Context的实现类ContextImpl类中就有用到这种方式的单例获取相关Service。

总结：大部分情况下，推荐使用带有volatile关键字的双重检查锁定和静态内部类。（希望以后能继续坚持写笔记和关于安卓的总结）