设计模式（2）单例模式

单例模式的作用是确保某个类只有一个实例，避免产生多个对象消耗过多的资源。比如对数据库的操作时，就可以使用单例模式。

单例实现

饿汉模式

这种写法是在类装载时就实例化instance，他避免了多线程的同步问题。但是不能保证有别的方式去装载，没有达到懒加载。

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

懒汉模式（线程不安全）

达到了懒加载，但是在多线程不能正常工作。

public class Singleton {
    private static Singleton instance;
    private Singleton () {
    }
    public static Singleton getInstance() {
    if (instance == null) {
        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();
        }
    }
    //代码块同步实现
    public static Singleton getInstance() {
        synchronized(Singleton.class) {
            if (instance == null) {
                instance = new Singleton();
            }
        }
    }
    return instance;
}

DCL单例（双重检查锁定）

这种写法在getSingleton方法中对singleton进行了两次判空，第一次是为了不必要的同步，第二次是为了在null的情况下创建实例。我们会发现上面代码有一个volatile关键字，因为在这里会有DCL失效问题，原因是Java编译器允许处理器乱序执行。那么为了解决这个问题，在JDK1.5之后，具体化了volatile关键字，只要定义时加上他，可以保证执行的顺序，虽然会影响性能。这种方式第一次加载时会稍慢，在高并发环境会有缺陷，但是一般能够满足需求。

• 不足之处：singleton = new Singleton()不是原子操作，JVM的即时编译器中存在指令重排序的优化
• volatile：禁止JVM指令重排序优化

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;
    }
}

静态内部类单例模式

这种是推荐使用的单例模式实现方式。当第一次加载Singleton类时并不会初始化INSTANCE，只有在第一次调用getInstance方法时才会导致INSTANCE被初始化。这种方式不仅能够保证线程安全，也能保证单例对象的唯一性，同时也延长了单例的实例化。

public class Singleton {
    private Singleton () {
    }
    public static final Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
    /**
     * 静态内部类
     */
    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }
}

枚举单例

这种方式是Effective Java作者Josh Bloch 提倡的方式，它不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

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

使用容器实现单例模式

将多种单例类型注入到一个统一的管理类中，在使用时根据key获取对象对应类型的对象。这种方式使得我们可以管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

public class SingletonManager {
　　private static Map<String, Object> objMap = new HashMap<String, Object>();

　　private SingletonManager() { }
　　public static void registerService(String key, Objectinstance) {
　　　　if (!objMap.containsKey(key) ) {
　　　　　　objMap.put(key, instance) ;
　　　　}
　　}

　　public static ObjectgetService(String key) {
　　　　return objMap.get(key) ;
　　}
}

Android源码中的单例模式

在Android系统中，我们经常会通过Context获取系统级别的服务，如WindowsManagerService、ActivityManagerService等，更常用的是一个LayoutInflater的类，这些服务会在合适的时候以单例的形式注册在系统中，在我们需要的时候就通过Context的getSystemService(String name)获取。

总结

优点：

（1）由于单例模式在内存中只有一个实例，减少了内存开支，特别是一个对象需要频繁的创建、销毁时，而且创建或销毁时性能又无法优化，单例模式的优势就非常明显。
（2）单例模式可以避免对资源的多重占用，例如一个文件操作，由于只有一个实例存在内存中，避免对同一资源文件的同时操作。
（3）单例模式可以在系统设置全局的访问点，优化和共享资源访问，例如，可以设计一个单例类，负责所有数据表的映射处理。

缺点：

（1）单例模式一般没有接口，扩展很困难，若要扩展，只能修改代码来实现。
（2）单例对象如果持有Context，那么很容易引发内存泄露。此时需要注意传递给单例对象的Context最好是Application Context。