单例

单例模式是一种对象的创建模式，用于产生一个对象的具体实例，他可以确保系统中，只有一个实例,减少new的次数，因而对系统内存的使用频率也会降低，减轻GC的压力，缩短GC停顿的时间

恶汉式单例

public class HungrySingle {
    private final static HungrySingle SINGLE = new HungrySingle();

    private HungrySingle() {
        System.out.println("HungrySingle is init");
    }

    public static HungrySingle instance() {
        return SINGLE;
    }

}

• 此种方式，是在虚拟机加载该类的时候，就加载该类的实例，无法对实例进行延时的加载

懒汉模式

public class LazySingle {
    public static LazySingle SINGLE = null;

    private LazySingle() {
    }

    public static LazySingle instance() {
        if (null == SINGLE) {
            SINGLE = new LazySingle();
        }
        return SINGLE;
    }
}

• 优点：保证了延时的加载
• 缺点：不能保证线程的安全，容易重复创建多个实例，在多线程的情况下，这种模式是失效的，无法保证单个实例

懒汉线程安全

public class LazySingle {
    public static LazySingle SINGLE = null;

    private LazySingle() {
    }

    //一种方式
    public static synchronized LazySingle instance01(){
        if (null==SINGLE){
            SINGLE = new LazySingle();
        }
        return SINGLE;
    }

    //二种方式
    public static LazySingle instance02() {
        synchronized (LazySingle.class) {
            if (null == SINGLE) {
                SINGLE = new LazySingle();
            }
            return SINGLE;
        }
    }
}

该方式保证了线程安全，但有点影响性能，

懒汉Dcl模式

public class LazySingle {
    public static LazySingle SINGLE = null;

    private LazySingle() {
    }
    public static LazySingle instance03() {
        //避免了不必要的同步
        if (null == SINGLE) {
            synchronized (LazySingle.class) {
                //初次的时候初始化对象
                if (null == SINGLE) {
                    SINGLE = new LazySingle();
                }
            }
        }
        return SINGLE;
    }
}

• 优点： 解决了性能问题，和线程安全的问题
• 缺点：1、在理想状态下，jvm先给对象分配内存，调用构造方法初始化对象，将对象指向分配的内存空间。jvm在及时编译器中有指令重排序的优化，不会完全按照这个步骤去创建对象，这个就造成了线程不安全的问题。

懒汉DCL优化

• 解决办法就是添加关键字 volatile 保证线程在本地不会存在instance的副本，每次都会到内存中去读取. 使用该关键字，就是禁用了jvm指令重排序优化，避免造成线程安全的问题

public class LazySingle {
    //添加 volatile关键字
    public static volatile LazySingle SINGLE = null;

    private LazySingle() {
    }

    public static LazySingle instance03() {
        //避免了不必要的同步
        if (null == SINGLE) {
            synchronized (LazySingle.class) {
                //初次的时候初始化对象
                if (null == SINGLE) {
                    SINGLE = new LazySingle();
                }
            }
        }
        return SINGLE;
    }
}

单例-静态内部类

• 推荐使用这种方式
• 静态内部类： jvm提供给我们的同步控制，static 可以进行区块初始化的操作，保证数据在内存是独一份的，final初始化之后，是无法被修改的，所也是线程安全的。(jvm在加载内的时候保证类的同步)
• 是要我们不使用内部类，就不会再次创建实例对象
• 这种方式是在性能，和线程安全上更有优化的

public class InnerStaticSingle {

    private InnerStaticSingle() {
    }
    
    public static InnerStaticSingle instance() {
        return SingleHolder.SINGLE;
    }
    //静态内部类
    private static class SingleHolder {
        private static final InnerStaticSingle SINGLE = new InnerStaticSingle();
    }
}

单例-枚举

• 写法简单，线程安全
• 不写实例方法的话，默认的情况下，枚举的创建是线程安全的，如果自己添加实例，需要注意线程安全.
• 注意：在使用成员变量和成员方法的时候，需要保证线程安全

public enum EnumSingle {
    //定义一个枚举的常量就是一个实例
    INSTANCE;
    //在使用成员变量和成员方法的时候，需要保证线程安全
    public void say() {
    }
}

Android 单例实际运用

• Application
• 单例引起内存年泄漏
• eventbus的坑