Android 单例和建造者 模式

Android 单例模式

是运用最广泛的设计模式之一， 单例模式的类必须保证只有一个实例存在。多用于整个程序只需要有一个实例，通常很消耗资源的类，比如线程池，缓存，网络请求，IO操作，访问数据库等。由于类比较耗资源，所以没必要让它构造多个实例，这种就是单例模式比较好的使用场景

饿汉式

1. 构造函数用private修饰，外部无法访问
2. 声明静态对象时就初始化
3. static关键字修饰，静态变量，存储在内存中，只有一份数据。
4. final关键字，只初始化一次，所以mInstance实例只有一个

public class SingletionStarving {

    private static final SingletionStarving mInstance = new SingletionStarving();

    private SingletionStarving() {

    }

    public static SingletionStarving getInstance() {
        return mInstance;
    }
}

懒汉式

1. 构造函数用private修饰，外部无法访问
2. 使用的时候即调用getInstance的时候才初始化
3. static关键字修饰，静态变量，存储在内存中，只有一份数据。
4. synchronized线程安全，多线程情况下单例的唯一性
5. 缺点：每次调用getInstance都会同步一次，浪费资源

public class SingletionSlacker {

    private static SingletionSlacker mInstance;

    private  SingletionSlacker() {}

    public static synchronized SingletionSlacker getInstance() {
        if (mInstance == null) {
            mInstance = new SingletionSlacker();
        }
        return mInstance;
    }
}

静态内部类方式 推荐使用

1. 构造函数用private修饰，外部无法访问
2. 使用的时候即调用getInstance的时候才初始化
3. 调用getInstance才回去加载SingletionInternalClassHolder类，确保了线程安全，保证了单例的唯一性。
4. 静态内部类不会在单例加载时就加载，而是在调用getInstance()方法时才进行加载，达到了类似懒汉模式的效果，而这种方法又是线程安全的。

public class SingletionInternalClass {

    private SingletionInternalClass() {}

    public static SingletionInternalClass getInstance() {
        return SingletionInternalClassHolder.instance;
    }

    private static class SingletionInternalClassHolder {
        private static final SingletionInternalClass instance = new SingletionInternalClass();
    }
}

双重校验锁法

• 双重校验锁法是线程安全的，并且，这种方法实现了lazyloading。

public class SingletonDemo {
    private static SingletonDemo instance;
    private SingletonDemo(){
        System.out.println("Singleton has loaded");
    }
    public static SingletonDemo getInstance(){
        if(instance==null){
            synchronized (SingletonDemo.class){
                if(instance==null){
                    instance=new SingletonDemo();
                }
            }
        }
        return instance;
    }
}

总结

单例模式不管用那种方式实现，核心思想都相同

1. 构造函数私有化，通过一次静态方法获取一个唯一实例
2. 线程安全

Builder模式

建造者模式是较为复杂的创建型模式，它将客户端与包含多个组成部分（或部件）的复杂对象的创建过程分离

1. 使用场景 ：Glide Okhttp AlertDialog
   当构建一个对象需要很多参数的时候，并且参数的个数或者类型不固定的时候
2. Builder模式的优点

• 松散耦合：生产器模式可以用同一个构建算法构建出表现不同的产品，实现产品构建和产品表现上的分离
• 很容易的改变产品的内部表示
• 复用性：生产器模式很好的实现构建算法和具体产品实现的分离

3. Builder模式的缺点

• 产生多余的 Builder 对象以及 Director 对象消耗内存
• 对象的构建过程暴露