android设计模式二十三式（二）——单例模式（Singleton）

我们先从创建型模式，按照顺序，慢慢来解开设计模式的面纱

单例模式

适用场合

1. 需要频繁的创建和销毁的对象；
2. 创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
3. 工具类对象；
4. 频繁访问数据库或文件的对象
5. 管理类对象；

1、饿汉式（静态常量）

public class Singleton { 
    private final static Singleton INSTANCE = new Singleton(); 

    private Singleton(){} 

    public static Singleton getInstance(){
        return INSTANCE; 
    } 
}

优点：写法简单，在类加载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有按需加载。如果从未使用过这个实例，会造成内存的浪费。

2、饿汉式（静态代码块）

public class Singleton { 

    private static Singleton instance; 

    static { 
        instance = new Singleton(); 
    }

    private Singleton() {} 

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

和上面的方式类似，只不过将类实例化的过程放在了静态代码块中，优缺点和上面一样。

3、懒汉式(线程不安全)--多线程下不建议使用

public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：起到了按需加载的效果

缺点：只能在单线程下使用，如果在多线程下，一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，会产生多个实例。所以线程不安全。

4、懒汉式(线程安全，同步方法)--不建议使用

public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public static synchronized Singleton getInstance() {
        if (singleton == null) {
            singleton = new Singleton();
        }
        return singleton;
    }
}

优点：解决了第三种线程不安全问题，做个线程同步就可以了，于是就对getInstance()方法进行了线程同步。

缺点：效率太低，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

5、懒汉式(线程不安全，同步代码块)--不建议使用

public class Singleton {
    private static Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                singleton = new Singleton();
            }
        }
        return singleton;
    }
}

优点：按需加载

缺点：虽然改为了同步产生实例化的代码块，但跟第3种实现方式遇到的情形一致，假如一个线程进入了if (singleton == null)判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。

6、双重检查

public class Singleton {
    private static volatile Singleton singleton;

    private Singleton() {
    }

    public static Singleton getInstance() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}

进行了两次非空检查，这样就可以保证线程安全了。这样，实例化代码只用执行一次，后面再次访问时，判断if (singleton == null)，直接返回实例化对象。

EventBus就是用的这种方式

    /** Convenience singleton for apps using a process-wide EventBus instance. */
    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

优点：线程安全；延迟加载；效率较高。

缺点：代码写起来较为复杂

7、静态内部类--本人最喜欢的单例模式方法

public class Singleton {
    private Singleton() {
    }

    private static class SingletonInstance {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。

类的静态属性只会在第一次加载类的时候初始化，所以在这里，借助JVM保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。

优点：避免了线程不安全，延迟加载，效率高。

缺点：需要理解类加载的机制，代码不容易理解

8、枚举

public enum Singleton {
    INSTANCE;

    public void whateverMethod() {
    }
}

优点：借助JDK1.5中添加的枚举来实现单例模式。不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

缺点：Android官网上已经明确指出应该在Android避免使用Enum，因为与静态常量相比，它对内存的占用要大很多。