面向对象的设计模式（一），单例模式

53 阅读 0 评论 35 点赞

我是靠谱客的博主可靠毛衣，最近开发中收集的这篇文章主要介绍面向对象的设计模式（一），单例模式，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

前言

面向对象语言具有封装，继承，多态等三个特性，同时，面向对象语言通常有好多种设计模式，这些设计模式在面向对象语言中是相通的，java是一种面向对象的语言，使用java语言作为开发语言的Android的源码中大量运用了设计模式。单例模式是应用最为广泛而且最为简单的一种设计模式。

单例模式：在任何时刻保证单例对象只存在一个实例，这个实例对象服务于整个系统，如：一个公司只有一个CEO，一个国家只有一个主席或者总统，一个宇宙只有一个地球。同时J2EE中的Application，Session及安卓中的Application都是单例。

实现单例模式的几种方式

实现单例模式需要注意一下几个关键点即可：

构造函数私有化，即权限设置为private
通过一个静态方法或者枚举返回单例类对象
确保单例类的实例只有一个，尤其是在多线程的情况下
确保单例类对象在反序列化是不会重新创建对象

通过将单例类的构造函数私有化，使得客户端代码不同通过new产生该类的实例。该单例类通过暴露一个方法给客户端，使得客户端通过该方法得到该单例类的唯一实例，通过还需要在获取该类的实例的过程中保证线程安全，即在多线程的情况下也不能出现单例类多个实例的情况，即单例类的实例在任何情况下都有且只有一个，并向整个系统提供使用。

以java语言为例，实现单例的方式有好多种：

1、懒汉模式（简单但不建议使用）

public class Singleton {
    public static Singleton mInstance;

    /**
     * 构造函数的私有化 
     */
    private Singleton (){

    }
    /**
     * 提供一个静态方法获取单例类的实例
     * @return
     */
    public static synchronized Singleton getInstance(){
        if(mInstance == null){
            mInstance = new Singleton();
        }
        return mInstance;
    }
}

这种方式简单，但是每次得到实例对象的时候都要同步，同步的过程是需要开销的，所以效率低，不推荐使用。

2、Double Check Lock(DCL)（一般可以考虑使用） –>改进的懒汉模式

public class Singleton {
    public static Singleton mInstance;

    /**
     * 构造函数的私有化 
     */
    private Singleton(){

    }
    /**
     * 提供一个静态方法获取单例类的实例
     * @return
     */
    public static Singleton getInstance(){
        if(mInstance == null){ // 第一次检查
            synchronized (Singleton.class) { // lock
                if(mInstance == null){ // 第二次检查
                    mInstance = new Singleton();
                }
            }
        }
        return mInstance;
    }
}

这个方式对懒汉模式做了一些改进，synchronized没有加在方法上，而是加在了方法体上。调用该方法的时候先检查实例对象是否为空，不为空直接放返回，为空就加同步（防止多线程出现多个实例的情况），并判断实例对象是否为空，为空就创建。这种方式只会在实例对象第一次为空的情况下同步。克服了懒汉模式每次请求得到实例都有同步，造成不必要的开销的缺点。

注意：该方法由于java内存模型的原因偶尔会失败，但是在绝大多数情况下可以保证单例对象的唯一性。

java的内存模型，在通过new新建一个实例的时候，这个新建语句最终会编译成多条汇编指令：
（1）给Singleton的实例分配内存
（2）调用Singleton()构造函数，初始化成员属性
（3）将该实例的引用mInstance 指向分配的内存空间

3、静态内部类实现单例（推荐）

public class Singleton {
    /**
     * 构造方法私有化
     */
    private Singleton(){

    }

    /**
     * 私有的内部静态类，使用了加载外部类的时候内部类不会立即加载的特性
     * @author lt
     *
     */
    private static class SingletonHolder{
        public static Singleton mInstance = new Singleton();
    }

    /**
     * 暴露一个方法取得单例对象的实例
     * @return
     */
    public static Singleton getInstance(){
        return SingletonHolder.mInstance;
    }
}

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

4、枚举单例（超级简单）

public enum Singleton {
    HELLO;
    public void println(String text){
        System.out.println(text);
    }
}

枚举与java中的普通类一样，不仅可以有字段，也可以有自己的方法，如果我们需要一个对象来实现一个简单的方法能完成的事件，如：Android中显示土司，那么我们就可以考虑使用枚举，并且枚举实例的创建默认是线程安全的，其他的类尽管将类的构造方法私有化了，但反序列化是会重新生成实例，而枚举不会。

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

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

    public static void putObj(String key,Object instance){
        if(!instances.containsKey(key)){
            instances.put(key, instance);
        }
    }

    public static Object getInstance(String key){
        return instances.get(key);
    }
}