转载请注明出处：http://blog.csdn.net/smartbetter/article/details/68953251

单例设计模式上应用最广的模式之一，在应用单例模式时，单例对象的类必须保证只有一个实例存在，而且可以自行实例化并向整个系统提供这个实例。一般在不能自由构造对象的情况下，就会使用单例设计模式，例如创建一个对象需要消耗资源过多，还有访问IO和数据库等资源等情况。

1.程序中使用单例模式的优缺点

1.优点

1）在内存中只有一个实例，减少了内存开支和性能开销；
2）可以避免对同一资源文件的同时写操作；
3）可以在系统设置全局的访问点，优化和共享资源访问，例如可以设计一个单例类，负责所有数据表的映射处理。

2.缺点

1）一般没有接口，扩展困难；
2）单例模式如果持有 Context，很容易引发内存泄漏，此时需要注意传递给单例对象的 Context 最好是 Application Context。

2.单例模式的实现方式

1.饿汉式

public class Singleton {
    /**
     * 单例模式(饿汉式)
     */
    private static final Singleton instance = new Singleton(); // 句柄
    private Singleton() {
    }
    public static Singleton getInstance() {
        return instance;
    }
}

2.懒汉式

优点是单例只有在使用时才会被实例化；缺点是第一次加载反应稍慢，每次调用
getInstance() 都进行同步，造成不必要的同步开销，一般不建议使用。

public class Singleton {
    /**
     * 单例模式(懒汉式)
     */
    private static Singleton instance; // 句柄
    private Singleton() {
    }
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

3.DCL方式

Double Check Lock 实现单例，优点是既能够在需要时才初始化单例，又能够保证线程安全，且单例对象初始化后调用 getInstance() 不进行同步锁；缺点是第一次加载反应稍慢。

public class Singleton {
    /**
     * 单例模式(DCL方式)
     */
    private volatile static Singleton instance = null; // 句柄
    private Singleton() {
    }
    public static Singleton getInstance() {
        if (instance == null) { // 避免不必要的同步
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

4.静态内部类方式——推荐使用

第一次加载不会初始化 Singleton，只有在第一次调用 Singleton 的 getInstance() 才会初始化，第一次调用会导致虚拟机加载 SingletonHolder 类，这种方式不仅能够确保线程安全，也能够保证单例对象的唯一性，同时也延迟了单例的实例化，推荐使用。

public class Singleton {
    /**
     * 单例模式(静态内部类的方式)
     */
    private Singleton() {
    }
    public static Singleton getInstance() {
        return SingletonHolder.instance;
    }
    private static class SingletonHolder {
        private static final Singleton instance = new Singleton();
    }
}

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

在初始，将多种单例类型注入到一个统一的管理类中，在使用时根据 key 获取对象对应类型的对象。可管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了耦合度。

public class SingletonManager {
    /**
     * 单例模式(使用容器实现单例模式)
     */
    private static Map<String, Object> objMap = new HashMap<>();
    private SingletonManager() {
    }
    public static void registerInstance(String key, Object instance) {
        if (objMap.containsKey(key)) {
            objMap.put(key, instance);
        }
    }
    public static Object getInstance(String key) {
        return objMap.get(key);
    }
}

不管以何种形式实现单例模式，它们的核心原理都是将构造函数私有化，并且通过静态方法获取一个唯一的实例，在这个获取的过程中必须保证线程安全、防止反序列化导致重新生成实例对象等问题，选择何种取决于项目本身，并发环境是否复杂、单例对象等资源消耗等。

序列化：将一个对象的实例写到磁盘，然后再读回来，从而获得一个实例。