设计模式之单例模式

       最近学习设计模式想着把学到的东西记录一下。同时也想翻一下Android源码，试图在Android源码里面翻出所有的设计模式。今天开始第一个模式--单例模式。

      单例模式：保证一个类仅有一个实例，并提供一个访问它的全局访问点。

       单例模式主要解决一个全局使用的类频繁地创建和销毁。当需要控制类的实例数量，节省系统资源时，应该考虑使用单例模式。

       优点：在内存中只有一个实例，减少了内存的开销，尤其是频繁的创建和销毁实例。避免对资源的多重占用。

       缺点：没有接口，不能继承，与单一职责原则冲突，一个类应该只关心内部逻辑，而不关心外面怎么样来实例话。

单例模式使用代码示例：

public class Main{
    public static void main(String[] args){
       SingleObject object = SingleObject.getInstance();//唯一获得实例的方式
    }
}

class SingleObject{
    private static SingleObject instance = new SingleObject();

    private SingleObject(){}//构造函数私有化，不让外部通过new创建对象

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

单例模式的实现方式：

       1、懒汉式，线程不安全

            懒汉式的“懒”，是指懒加载，那懒加载是啥呢？我们知道，程序在运行时，当需要用到哪个Java文件的时候，JVM就会加载哪个文件，并且完成静态变量，静态代码块的执行。那么这里的懒加载值得就是在JVM加载这个单例模式类的时候，创建的这个单例类对象没有一开始就new出来，而是在getInstance方法中初始化。这种方式是最基本的实现方式，它最大的问题是不支持多线程。因为没有加锁synchronized，所以严格意义上不算单例模式。这种方式懒加载很明显，不要求线程安全，在多线程不能正常工作。

public class Singleton{
    private static Singleton instance = null;
    
    private Singleton(){}//私有构造函数

    public static Singleton getInstance(){
        if(instance == null){
            instance = new Singleton();//为null时赋值
        }
        return instance;
    }
}

        2、懒汉式，线程安全。

           这种方式具备很好的懒加载，能够在多线程中很好的工作，但是，效率很低，99%情况下不需要同步。优点：第一次调用初始化，避免内存浪费。缺点，必须加锁synchronized才能保证单例，加锁会影响效率。

public Singleton{
    private static Singleton instance = null;
    private Singleton(){}//构造函数私有
    public static synchronized Singleton getInstance(){//加了锁
        if(instance == null){
            instance = new Singleton();
        }
        return instance;
    }
}

       3、饿汉式 

            这种方式与懒加载相比，它在JVM加载Java文件的时候给静态成员instance进行了初始化，可以形象的比喻成一个饿久了的汉子迫不及待的要吃到东西，所以一开始就赋值。所以它不是懒加载，同时它是线程安全的，因为instance是类的静态成员，不管何时何地，这个类都只保存一个instance对象。它的优点是：没有加锁，执行效率会提高。缺点：类加载时就初始化，浪费内存。

public class Singleton{
    private static Singleton instance = new Singleton();//类加载时就初始化
    private Singleton(){}//构造函数私有化
    public static Singleton getInstance(){
        return instance;
    }
}

        4、双重校验锁

          这种方式采用双锁机制，安全且在多线程情况下能保持高性能。同时这种方式可以达到懒加载的效果。

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

           5、登记室/静态内部类

               这种方式对于我来说是一种全新的方式，以前没见过。先看代码。

public class Singleton{
    private static class SingletonHolder{//私有内部类
        public static final Singleton INSTANCE = new Singleton();
    }
    private Singleton(){}//构造函数私有化
    public static Singleton getInstance(){
        return SingletonHolder.INSTANCE;
    }
}

             通过上述代码，可以看出，这种方式实现比较简单，它也能在多线程情况下保持高性能。这种方式适用于静态域延迟初始化。双捡锁方式可在实例域需要延迟初始化时使用。这种方式也是利用类加载机制来保证初始化instance时只有一个线程，它跟双捡锁方式的不同之处在于，双捡锁在类加载的时候就进行instance的初始化。而在这种方式下，Singleton类被加载的时候，内部类（没有被主动使用）不一定在这个时候加载，instance不一定被初始化。如果实例话instance很消耗资源，想让它延迟加载，又不希望在Singleton类加载时就实例化。这时候使用静态内部类方式是很合理的。

         6、枚举

          这种方式我也没遇到过。据说是没有广泛采用，但它是单例模式最佳方法。它更简洁，自动支持序列化机制，绝对防止多次实例化。它是线程安全的，但不是懒加载。

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

         单例模式的创建方式就是以上六种。

经验之谈：一般情况下，不建议使用第 1 种和第 2 种懒汉方式，建议使用第 3 种饿汉方式。只有在要明确实现 lazy loading 效果时，
才会使用第 5 种登记方式。如果涉及到反序列化创建对象时，可以尝试使用第 6 种枚举方式。如果有其他特殊的需求，可以考虑使用
第 4 种双检锁方式。

 

在Android中，也有一个类转门生成单例，源代码如下：

public abstract class Singleton<T> {
    private T mInstance;

    protected abstract T create();

    public final T get() {
        synchronized (this) {
            if (mInstance == null) {
                mInstance = create();
            }
            return mInstance;
        }
    }
}

         它有点像第二种方式。懒汉式线程安全～

    文章编写总结自单例模式 和《大话设计模式》