单例模式

一、定义：
确保某一个类只有一个实例， 而且自行实例化并向整个系统提供这个实例。
二、类图：

三、代码：

1. 懒汉式单例

/**
 * 懒汉式单例
 */
public class Singleton {

    private static Singleton mInstance=null;//唯一实例
    /**
     * 私有构造方法，保证外部无法通过new关键字进行实例化
     */
    private Singleton(){}
    /**
     * 静态公共方法，提供给外部，用于获取Singleton的唯一实例
     * @return
     */
    public static Singleton getInstance(){
        if (mInstance==null){//实例为空时才创见
            mInstance=new Singleton();//只能在本类实例化，外部无法调用私有构造函数进行实例化
        }
        return mInstance;
    }
}

此种写法是线程不安全的，设想一下，在高并发情况下，可能一个实例还在创建过程中（mInstance还为null），此时，又有一个实体调用getInstance方法，就会出现实例化多个对象的情况，即：违背了单例模式的初衷。因此，为了保证线程安全，还有下面3种写法：
2.在getInstance（）方法上加同步

/**
 * 懒汉式单例
 */
public class Singleton {

    private static Singleton mInstance=null;//唯一实例
    /**
     * 私有构造方法，保证外部无法通过new关键字进行实例化
     */
    private Singleton(){}
    /**
     * 静态公共方法，提供给外部，用于获取Singleton的唯一实例
     * getInstance方法加synchronized关键字，保证线程安全
     * @return
     */
    public static synchronized Singleton getInstance(){
        if (mInstance==null){//实例为空时才创见
            mInstance=new Singleton();//只能在本类实例化，外部无法调用私有构造函数进行实例化
        }
        return mInstance;
    }
}

这种写法可以保证线程安全，但每次调用方法都需要同步，影响性能，毕竟99%的情况下是不需要同步的。
3.双重检验锁定

/**
 * 懒汉式单例
 */
public class Singleton {

    private static Singleton mInstance=null;//唯一实例
    /**
     * 私有构造方法，保证外部无法通过new关键字进行实例化
     */
    private Singleton(){}
    /**
     * 静态公共方法，提供给外部，用于获取Singleton的唯一实例
     *双重检验锁定，保证线程安全
     * @return
     */
    public static Singleton getInstance(){
        if (mInstance==null){
            synchronized (Singleton.class){
                if (mInstance==null){//双重检验
                    mInstance=new Singleton();//只能在本类实例化，外部无法调用私有构造函数进行实例化
                }
            }
        }
        return mInstance;
    }
}

较之第2种写法，这种写法只是第一次初始化的时候才需要同步一次，既保证线程安全，又避免了同步带来的性能问题。
4.静态内部类

/**
 * 懒汉式单例
 */
public class Singleton {
    //静态内部类
    private static class InnerSingleton{
        private static final Singleton mInstance=new Singleton();//唯一实例
    }
    /**
     * 私有构造方法，保证外部无法通过new关键字进行实例化
     */
    private Singleton(){}
    /**
     * 静态公共方法，提供给外部，用于获取Singleton的唯一实例
     */
    public static final Singleton getInstance(){
        return InnerSingleton.mInstance;
    }
}

这种方式，用classloader的机制来保证初始化instance的时候只有一个线程，既保证线程安全，又避免性能损耗。
5.饿汉式单例

**
 * 饿汉式单例
 */
public class Singleton {

    private static final Singleton mInstance=new Singleton();//类创建时即创建一个静态的实例供外部使用，以后不会改变，天生线程安全
    /**
     * 私有构造方法，保证外部无法通过new关键字进行实例化
     */
    private Singleton(){}
    /**
     * 静态公共方法，提供给外部，用于获取Singleton的唯一实例
     * @return
     */
    public static Singleton getInstance(){
        return mInstance;
    }
}

在类创建的时候即实例化一个对象，不管以后用不用，都会占用内存，但也保障了在第一次调用时，速度会很快，因为其资源已经初始化完成。
四、优点：
1.由于单例模式在内存中只有一个实例， 减少了内存开支， 特别是一个对象需要频繁地创建、 销毁时， 而且创建或销毁时性能又无法优化， 单例模式的优势就非常明显。
2.由于单例模式只生成一个实例， 所以减少了系统的性能开销， 当一个对象的产生需要比较多的资源时， 如读取配置、 产生其他依赖对象时， 则可以通过在应用启动时直接产生一个单例对象， 然后用永久驻留内存的方式来解决。
3.单例模式可以避免对资源的多重占用， 例如一个写文件动作， 由于只有一个实例存在内存中， 避免对同一个资源文件的同时写操作。
4.单例模式可以在系统设置全局的访问点， 优化和共享资源访问， 例如可以设计一个单例类， 负责所有数据表的映射处理。
五、缺点：
1.单例模式一般没有接口， 扩展很困难， 若要扩展， 除了修改代码基本上没有第二种途径可以实现。
2.单例模式对测试是不利的。 在并行开发环境中， 如果单例模式没有完成， 是不能进行测试的。
3.单例模式与单一职责原则有冲突。 一个类应该只实现一个逻辑， 而不关心它是否是单例的， 是不是要单例取决于环境， 单例模式把“要单例”和业务逻辑融合在一个类中。