浅谈设计模式——单例模式

如需转载请注明出处

一、什么是单例
1、单例的概念
单例模式市一中对象创建模式，它用于产生一个对象的一个具体事例，它可以确保系统中一个类只产生一个实例。
2、好处
对于频繁使用的对象，可以省略创建对象所花费的时间，这对于那些重量级对象而言，是非常可观的一笔系统开销；
由于new操作的次数减少，因而对系统内存的使用频率也会降低，这将减轻GC压力，缩短CC停顿时间；

二、单例的六种写法和各自的特点
饿汉/懒汉/懒汉线程安全/DCL/静态内部类/枚举

单例——饿汉

public class HungurySingleton {

    //变量必须是静态、私有
    private static final HungurySingleton mHungurySingleton = new HungurySingleton();

    //构造方法私有
    private HungurySingleton(){
        System.out.println("Singleton is created");
    }

    //必须是公共、静态方法
    public static HungurySingleton getHungurySingleton(){
        return mHungurySingleton;
    }
}

饿汉不足：
无法对instance实例做延迟加载，每次都会创建instance对象。
优化：懒汉

单例——懒汉

public class LazySingleton {

    //静态、私有
    private static LazySingleton instance;
    //构造方法私有
    private LazySingleton(){}

    public static LazySingleton getInstance(){
        //第一次调用时会被初始化
        if(instance==null){
            instance = new LazySingleton();
        }
        return instance;
    }
}

懒汉不足：
在多线并发下这样的实现是无法保证实例是唯一的
优化：懒汉线程安全

单例——懒汉线程安全

public class LazySafetySingleton {

    private static LazySafetySingleton instance;
    private LazySafetySingleton(){}

    //（法一）方法中声明synchronized关键字
    public static synchronized LazySafetySingleton getInstance(){
        if(instance==null){
            instance = new LazySafetySingleton();
        }
        return instance;
    }

    //（法二）同步代码块实现
    public static LazySafetySingleton getInstancel(){
            synchronized (LazySafetySingleton.class){
                if (instance==null){
                    instance = new LazySafetySingleton();
                }
            }
        return instance;
    }  
}

懒汉线程安全不足：
性能
优化：DCL

单例——DCL

public class DclSingleton {

    //volatile 保证线程在本地不会存有instance副本，每次都会到内存中读取
    private static volatile DclSingleton instance;
//    private static DclSingleton instance;
    private DclSingleton(){}

    public static  DclSingleton getInstance(){
        //避免不必要的同步
        if  (instance==null){
            //同步
            synchronized (DclSingleton.class){
                //在第一次调用时初始化
                if (instance==null){
                    instance = new DclSingleton();
                }
            }

        }
        return instance;
    }

DCL不足：
JVM的即时编译器存在指令重排序的优化（解决办法：instance变量声明volatile）
优化：静态内部类/枚举

单例——静态内部类
优点：
确保Singleton类的唯一性且可以延迟加载;
没使用synchronized关键字，性能更好;
JVM本身的机制保证了线程安全（static、final）；

public class StaticInnerSingleton {
    private StaticInnerSingleton(){}
    public static StaticInnerSingleton getInstance(){
        return SingletonHolder.sInstance;
    }
    //静态内部类，私有，外部无法访问
    private static class SingletonHolder{
        //私有、静态、final
        private static final StaticInnerSingleton sInstance = new StaticInnerSingleton();
    }
} 

单例——枚举
优点：
写法简单/线程安全

public enum EnumSingleton {
    INSTANCE;
    public void doSomeThing(){
        //do someting...
    }
}

三、总结
饿汉：无法对instance实例进行延迟加载；
懒汉：多线程并发情况下无法保证实例的唯一性；
懒汉线程安全：使用synchronized导致性能缺陷；
DCL：JVM即时编译期器的指令重排序；
静态内部类/枚举：延迟加载/线程安全/性能优势；

四、android中的单例
1、application
通过application对象获取全局context

public class ExampleApp extends Application {

    public static ExampleApp instance;
    public static ExampleApp getInstance(){
        return instance;
    }
    @Override
    public void onCreate() {
        super.onCreate();
        instance = this;
    }
}

例如：

ExampleApp.getInstance().getExternalFilesDir(null);

2、单例模式引起的内存泄漏
3、eventbus的坑
未完，待续...