Android常用设计模式总结-待续

设计模式总结
1.单例模式具有以下几个优点：
 1)在内存中只有一个对象，节省内存空间；
 2)避免频繁的创建销毁对象，可以提高性能；
 3)避免对共享资源的多重占用，简化访问；
 4)为整个系统提供一个全局访问点。
场景：
需要频繁的进行创建和销毁的对象；
创建对象时耗时过多或耗费资源过多，但又经常用到的对象；
工具类对象；
频繁访问数据库或文件的对象。

饿汉式：简单来说就是空间换时间，因为上来就实例化一个对象，占用了内存，(也不管你用不用)。绝对线程安全，立即加载。
（由于一个类在整个生命周期中只会被加载一次，因此该单例类只会创建一个实例）
场景：试用于创建对象次数多的场景。
//饿汉式单例
public class Singleton1 {
 
    // 指向自己实例的私有静态引用，主动创建
    private static Singleton1 singleton1 = new Singleton1();
 
    // 私有的构造方法
    private Singleton1(){}
 
    // 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static Singleton1 getSingleton1(){
        return singleton1;
    }
}

懒汉式：简单来说就是时间换空间，于饿汉式正好相反。传统式的懒汉式单例是非线程安全的，延时加载。
场景：试用于创建对象次数少的场景。
// 懒汉式单例,非线程安全的
public class Singleton2 {
 
    // 指向自己实例的私有静态引用
    private static Singleton2 singleton2;
 
    // 私有的构造方法
    private Singleton2(){}
 
    // 以自己实例为返回值的静态的公有方法，静态工厂方法
    public static Singleton2 getSingleton2(){
        // 被动创建，在真正需要使用时才去创建
        if (singleton2 == null) {
            singleton2 = new Singleton2();
        }
        return singleton2;
    }
}

推荐试用：
// 线程安全的懒汉式单例
同步延迟加载 — 使用内部类实现延迟加载
public class Singleton5 {
 
    // 私有内部类，按需加载，用时加载，也就是延迟加载
    private static class Holder {
        private static Singleton5 singleton5 = new Singleton5();
    }
    // 私有的构造方法
    private Singleton5() {}
 
    public static Singleton5 getSingleton5() {
        return Holder.singleton5;
    }
}
/* Output(完全一致)

双重检测同步延迟加载
public class Singleton3 {
 
    //使用volatile关键字防止重排序，因为 new Instance()是一个非原子操作，可能创建一个不完整的实例
    private static volatile Singleton3 singleton3;
     // 私有的构造方法
    private Singleton3() {}
 
    public static Singleton3 getSingleton3() {
        // Double-Check idiom
        if (singleton3 == null) {
            synchronized (Singleton3.class) {  
                // 只需在第一次创建实例时才同步
                if (singleton3 == null) {      
                    singleton3 = new Singleton3();
                }
            }
        }
        return singleton3;
    }
}/* Output(完全一致)