【编程素质】设计模式-单例模式（Singleton pattern）

1，概念

单例模式（Singleton pattern，单件模式，单子模式）：
确保有一个类只有一个实例，并提供一个全局访问点。

单例设计模式是设计模式中简单且常用的一种。

2，场景

1）场景

单例模式只允许创建一个对象，因此节省内存，加快对象访问速度，因此对象需要被公用的场合适合使用，如多个模块使用同一个数据源连接对象等等。
① 资源共享的情况下，避免由于资源操作时导致的性能或损耗等。如上述中的日志文件，应用配置。
②控制资源的情况下，方便资源之间的互相通信。如线程池等。

2）使用

①需要频繁实例化然后销毁的对象。
② 创建对象时耗时过多或者耗资源过多，但又经常用到的对象。
③有状态的工具类对象。
④频繁访问数据库或文件的对象。

3）举例

① 外部资源：每台计算机有若干个打印机，但只能有一个PrinterSpooler，以避免两个打印作业同时输出到打印机。内部资源：大多数软件都有一个（或多个）属性文件存放系统配置，这样的系统应该有一个对象管理这些属性文件
②Windows的Task Manager（任务管理器）就是很典型的单例模式（这个很熟悉吧），想想看，是不是呢，你能打开两个windows task manager吗？ 不信你自己试试看哦~
③windows的Recycle Bin（回收站）也是典型的单例应用。在整个系统运行过程中，回收站一直维护着仅有的一个实例。
④网站的计数器，一般也是采用单例模式实现，否则难以同步。
⑤应用程序的日志应用，一般都何用单例模式实现，这一般是由于共享的日志文件一直处于打开状态，因为只能有一个实例去操作，否则内容不好追加。
⑥Web应用的配置对象的读取，一般也应用单例模式，这个是由于配置文件是共享的资源。
⑦数据库连接池的设计一般也是采用单例模式，因为数据库连接是一种数据库资源。数据库软件系统中使用数据库连接池，主要是节省打开或者关闭数据库连接所引起的效率损耗，这种效率上的损耗还是非常昂贵的，因为何用单例模式来维护，就可以大大降低这种损耗。
⑧多线程的线程池的设计一般也是采用单例模式，这是由于线程池要方便对池中的线程进行控制。
⑨操作系统的文件系统，也是大的单例模式实现的具体例子，一个操作系统只能有一个文件系统。
⑩HttpApplication 也是单例的典型应用。熟悉ASP.Net(IIS)的整个请求生命周期的人应该知道HttpApplication也是单例模式，所有的HttpModule都共享一个HttpApplication实例.
⑪在某个服务器程序中，该服务器的配置信息存放在一个文件中，这些配置数据由一个单例对象统一读取，然后服务进程中的其他对象再通过这个单例对象获取这些配置信息。这种方式简化了在复杂环境下的配置管理。

3，优缺点

优

①全局变量的替换

单件可以延迟实例化（没有全局变量的缺点）。

②保障了对象的唯一性

避免了对共享资源的多重占用。
解决了多个实例引发的问题：如：程序的行为异常、资源使用过量、不一致的结果。无论别的类中建立了多少个Single实例，都只在内存中有的一个Single实例。

缺

①不适用于变化的对象

如果同一类型的对象总是要在不同的场景发生变化，单例模式就会引发数据的错误，不能保存彼此的状态。

②滥用单例模式

如为了节省资源将数据库连接池对象设计为的单例类，可能会导致共享连接池对象的程序过多而出现连接池溢出；
如果实例化的对象长时间不被利用，系统会认为是垃圾而被回收，这将导致对象状态的丢失。
使用注意事项：

4，实现

（1）设计模式实现

提供这个实例的全局访问点，当需要实例时，通过查询单件类，返回单个实例。

①将构造函数私有化。

为了避免其它程序过多建立该类对象，先禁止其他程序建立该类对象。

②在类中创建一个本类对象。

为了其他程序可以访问到该类对象，在本类中，自定义一个对象。

③提供一个方法获取到该对象。

为了方便其他程序对自定义对象访问，可以对外提供一些访问方式。
（引用自 黑马程序员 ）

2）Android中单例模式

①activity的单例模式

Android中xml实现，设置 activity的启动模式。
Android中除了以上的实现方法，对于Activity的单例模式是通过在AndroidMainfest.xml中定义以下代码实现的。

android:launchMode="singleInstance"

②其它类单例模式

包括Fragment，用GOF单例模式即可。

③Application

Application比较特殊，具体写法参考：Context类和Application类

public class MyApplicationextends Application {

    private static MyApplication instance;

    @Override
    public void onCreate() {
        super.onCreate();
        instance = this;
    }

    public static AndroidApplication getInstance(){
        return instance;
    }
}

④单例模式的应用

i>输入法类InputMethodManager

public final class InputMethodManager {
    //内部全局唯一实例  
    static InputMethodManager sInstance;

    //对外api  
    public static InputMethodManager getInstance() {
        synchronized (InputMethodManager.class) {
            if (sInstance == null) {
                IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
                IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
                sInstance = new InputMethodManager(service, Looper.getMainLooper());
            }
            return sInstance;
        }
    }
} 

ii>Calendar实例的获取
获取日历：

Calendar calendar = Calendar.getInstance();获取的是当前日历的时间

5，代码

1）懒汉式（不推荐）

①概念

Singleton类进内存时，对象还没有存在。对象是方法被调用时，才初始化，也叫做对象的延时调用。
利用双重检查加锁（double-checked locking)

②场景

需要外部传参才能创建对象时使用。
使用时注意线程 安全问题。

③优缺点

优点：
避免了饿汉式的那种在没有用到的情况下创建事例，资源利用率高，不执行getInstance()就不会被实例，可以执行该类的其他静态方法。
缺点：
懒汉式在单个线程中没有问题，但多个线程同事访问的时候就可能同事创建多个实例，而且这多个实例不是同一个对象，虽然后面创建的实例会覆盖先创建的实例，但是还是会存在拿到不同对象的情况。解决这个问题的办法就是加锁synchonized，第一次加载时不够快，多线程使用不必要的同步开销大。

④实现

双重校验锁（Double Check Lock，DCL）

package Singleton;

/**
 * 懒汉式
 * Singleton类进内存时，对象还没有存在。对象是方法被调用时，才初始化，也叫做对象的延时调用。
 * 利用双重检查加锁（double-checked locking)
 * @author luo
 */
class Singleton {
    private Singleton() {
    }
    /**
     * volatile关键词确保：当instance变量被初始化成Singleton实例时，多个线程正确地处理instance变量
     */
    private volatile static Singleton instance = null;
    /**
     * 双重检查加锁
     * 首先检查是否实例已经创建了，如果尚未创建，才进行同步区块。
     * 这样只有第一次会同步。
     * @return
     */
    public static Singleton getInstance() {
        if (null == instance) {//在instance已经实例化后下次进入不必执行synchronized (Singleton.class)获取对象锁，从而提高性能
            synchronized (Singleton.class) {
                // 加锁，只有第一次才彻底执行
                if (instance == null) {
                    //进入区块后，再检查一次，如果仍是null，才创建实例
                    instance = new Singleton();
                }
            }
        }
        return instance;

    }

    /*
     * 验证
     */
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

1.给Singleton 分配内存
2.调用Singleton 的构造函数，初始化成员字段
3.将instance 对象指向分配的内存空间（此时instance 就不是null 了）

jdk 1.5 以后java 编译器允许乱序执行 。所以执行顺序可能是1-3-2 或者 1-2-3。如果是前者先执行3 的话，切换到其他线程，instance 此时 已经是非空了，此线程就会直接取走instance ，直接使用，这样就回出错。DCL 失效。解决方法 SUN 官方已经给我们了。将instance 定义成 private volatile static Singleton instance = null 即可

2）饿汉式（推荐）

①概念

先初始化对象。Singleton类一进内存就加载对象。

②场景

不需要外部传参使用。使用比较简单，比懒汉式常用。

③优缺点

优点
1.线程安全
2.在类加载的同时已经创建好一个静态对象，调用时反应速度快
缺点
资源效率不高，可能getInstance()永远不会执行到，但执行该类的其他静态方法或者加载了该类（class.forName)，那么这个实例仍然初始化

④实现

package Singleton;

public class Main {

    public static void main(String[] args) {    

        Singleton1 s11 = Singleton1.getInstance();
        Singleton1 s12 = Singleton1.getInstance();

        s11.setName("饿汉式单件");
        System.out.println(s12.getName());// 说明s11 s12指向同一个对象
    }
}

package Singleton;
/**
 * 饿汉式
 * 先初始化对象。Singleton类一进内存就加载对象。
 * @author luo
 */
class Singleton1 {
    private Singleton1() {
    }
    private static Singleton1 instance = new Singleton1();
    public static Singleton1 getInstance() {
        return instance;
    }
    /*
     * 验证
     */
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

3）静态内部类（推荐）

①场景

一般采用饿汉式，若对资源十分在意可以采用静态内部类，不建议采用懒汉式及双重检测 。
采用内部类，在这个内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM 就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载和线程安全。

②优缺点

优点
资源利用率高，不执行getInstance()不被实例，可以执行该类其他静态方法
缺点
第一次加载时反应不够快

③实现

public class Singleton{
    //内部类，在装载该内部类时才会去创建单利对象
    private static class SingletonHolder{
        public static Singleton instance = new Singleton();
    }

    private Singleton(){}

    public static Singleton newInstance(){
        return SingletonHolder.instance;
    }

    public void doSomething(){
        //do something
    }
}

4）枚举单例

①概念

Effective Java中推荐了一种更简洁方便的使用方式，就是使用枚举。
默认枚举实例的创建是线程安全的.(创建枚举类的单例在JVM层面也是能保证线程安全的), 所以不需要担心线程安全的问题，所以理论上枚举类来实现单例模式是最简单的方式。

②场景

线程安全，实现简单。
反序列化的时候，不会重新创建对象。

③实现

public enum Singleton{
    //定义一个枚举的元素，它就是Singleton的一个实例
    instance;

    public void doSomething(){
        // do something ...
    }    
}

使用：

public static void main(String[] args){
   Singleton singleton = Singleton.instance;
   singleton.doSomething();
}

④反序列化

要杜绝单例对象在反序列化时重新生成对象，那么必须加入如下方法：

private Object readResolve() throws ObjectStreamException{
    return instance;
}

如果你的单例类维持了其他对象的状态的话，因此你需要使他们成为transient的对象。
但是枚举单例，JVM对序列化有保证；反序列化时，不会生成新的实例。

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

③概念

将众多单例模式类型注入到一个统一的管理类中，在使用时根据key 对应类型的对象。

②场景

便于管理多种类型的单例，并且在使用时可以通过统一的接口进行获取操作，降低了用户的使用成本，也对用户隐藏了具体实现，降低了耦合度。

③实现

public class SingletonManager{
    private static Map obMap = new hashMap();
    private SingletonManager(){}
    public static void registerService(String key, Object instance){
        if(!obMap.containKey(key)){
            obMap.put(key,instance);
        }
    }

    public static Object getService(String key){
        return obMap.get(key);
    }
}