android 单例的好处 使用单例模式的好处

单例模式的优点

我们从单例模式的定义和实现，可以知道单例模式具有以下几个优点：

1.在内存中只有一个对象，节省内存空间；

2.避免频繁的创建销毁对象，可以提高性能；

3.避免对共享资源的多重占用，简化访问；

4.为整个系统提供一个全局访问点。

单例模式的使用场景

由于单例模式具有以上优点，并且形式上比较简单，所以是日常开发中用的比较多的一种设计模式，其核心在于为整个系统提供一个唯一的实例，其应用场景包括但不仅限于以下几种：
　　
1.有状态的工具类对象；

2.频繁访问数据库或文件的对象；

饿汉式

public class Hungry {

    private Hungry(){};

    private static Hungry HUNGRY = new Hungry();//加载类的时候就创建了对象

    private static Hungry getInstance(){
        return HUNGRY;
    }
}

我们已经在上面提到，类加载的方式是按需加载，且只加载一次。因此，在上述单例类被加载时，就会实例化一个对象并交给自己的引用，供系统使用。换句话说，在线程访问单例对象之前就已经创建好了。再加上，由于一个类在整个生命周期中只会被加载一次，因此该单例类只会创建一个实例，也就是说，线程每次都只能也必定只可以拿到这个唯一的对象。因此就说，饿汉式单例天生就是线程安全的。

单线程懒汉式

//单线程下懒汉式
public class Lazy {
    private Lazy(){};

    private static Lazy Lazy;

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

上面发生非线程安全的一个显著原因是，会有多个线程同时进入 if (Lazy==null) {…} 语句块的情形发生。当这种这种情形发生后，该单例类就会创建出多个实例，违背单例模式的初衷。因此，传统的懒汉式单例是非线程安全的。

多线程懒汉式

1.synchronized整个方法

//多线程懒汉式：synchronized整个方法
public class Lazy2 {
    private Lazy2(){};

    private static Lazy2 Lazy2;

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

该实现与上面传统懒汉式单例的实现唯一的差别就在于：是否使用 synchronized 修饰 Lazy2 ()方法。若使用，就保证了对临界资源的同步互斥访问，也就保证了单例。

从执行结果上来看，问题已经解决了，但是这种实现方式的运行效率会很低，因为同步块的作用域有点大，而且锁的粒度有点粗。同步方法效率低，那我们考虑使用同步代码块来实现。

2.synchronized方法块

//多线程懒汉式：synchronized方法块
public class Lazy3 {
    private Lazy3(){};

    private static Lazy3 Lazy3;

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

    public static void main(String[] args) {
        for (int i=0;i<5;i++){
            new Thread(()->{
                Lazy3 lazy3 = Lazy3.getInstance();
                System.out.println(lazy3);
            }).start();
        }
    }
}

3.静态内部类

//多线程懒汉式：静态内部类
public class Lazy4 {
    private Lazy4(){};

    public static class Holder{
        private static Lazy4 Lazy4 = new Lazy4();
    }
    public static Lazy4 getInstance(){
        return Holder.Lazy4;
    }
}

（1）懒汉：静态内部类不会随着外部类的加载而加载 ,只有静态内部类的静态成员被调用时才会进行加载
（2）多线程安全：虚拟机会保证一个类的构造器()方法在多线程环境中被正确地加载，同步，如果多个线程同时去初始化一个类，那么只有一个线程去执行这个类的构造器()方法，其他线程都需要阻塞等待，直到活动线程执行()方法完毕。

4.双重检测DCL(Double-Check idiom)

//多线程懒汉式：双重检测DCL
public class Lazy5 {
    private Lazy5(){};
    /*
    使用volatile关键字防止重排序，因为 new Instance()是一个非原子操作，可能创建一个不完整的实例
    1:分配对象的内存空间
    2:初始化对象
    3:使Lazy5指向刚分配的内存地址
    正常顺序123
    异常顺序132
    此行代码创建了一个 Lazy5 对象并初始化变量 Lazy5 来引用此对象。
    这行代码存在的问题是，在 Lazy5 构造函数体执行之前，变量 Lazy5 可能提前成为非null的，即赋值语句在对象实例化之前调用
    此时别的线程将得到的是一个不完整（未初始化）的对象，会导致系统崩溃。
     */
    private static volatile Lazy5 Lazy5;

    public static Lazy5 getInstance(){
        //第一层检测
        if (Lazy5==null){
            synchronized (Lazy5.class){
                //第二层检测
                if (Lazy5==null){
                    Lazy5 = new Lazy5();
                }
            }
        }
        return Lazy5;
    }
}

第一次校验： 也就是第一个if（Lazy5==null），这个是为了代码提高代码执行效率，由于单例模式只要一次创建实例即可，所以当创建了一个实例之后，再次调用getInstance方法就不必要进入同步代码块，不用竞争锁。直接返回前面创建的实例即可。

第二次校验： 也就是第二个if（Lazy5null），这个校验是防止二次创建实例，假如有一种情况，当Lazy5还未被创建时，线程t1调用getInstance方法，由于第一次判断Lazy5null，此时线程t1准备继续执行，但是由于资源被线程t2抢占了，此时t2页调用getInstance方法。

同样的，由于singleton并没有实例化，t2同样可以通过第一个if，然后继续往下执行，同步代码块，第二个if也通过，然后t2线程创建了一个实例Lazy5。

此时t2线程完成任务，资源又回到t1线程，t1此时也进入同步代码块，如果没有这个第二个if，那么，t1就也会创建一个Lazy5实例，那么，就会出现创建多个实例的情况，但是加上第二个if，就可以完全避免这个多线程导致多次创建实例的问题。

所以说：两次校验都必不可少。

5.枚举

//多线程懒汉式：枚举
public enum Lazy6 {
    INSTANCE;
    public Lazy6 getInstance(){
        return INSTANCE;
    }
}

用枚举实现的懒汉式是为了防止反射暴力破解，之前的四种都是无法防范反射暴力破解单例的