单例模式

单例模式

单例模式是为了确保某个实例只会被初始化一次,确保我们每次使用到的对象都是同一个,这样能够大大节约应用占用的内存。

单例写法

单例模式的写法很多,还分懒汉式跟饿汉式,区别就在于一个是需要时才实例化一个是类被加载时就完成实例化。我们来看一下合理的且常见的几种懒汉单例写法

DCL(Double Check Lock,双重检查锁)

public class Singleton {

    private static Singleton sSingleton;

    private Singleton(){}

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

}

DCL双重检查锁。内层检查是为了支持线程并发,保证在并发情况下单例的保持,外层检查是为了在处理同步问题后进一步提升代码效率。这种写法问题在于代码重拍导致判断失误。

代码重拍问题

首先,new Singleton()不是一个原子操作,它可以分为:分配内存空间、初始化对象、将对象指向分配的内存空间。而且只有在将对象指向分配的内存控件后sSingleton != null才成立。在编译器编译时为了优化单线程中的执行性能是可以将2,3两步进行重排。重拍后就变成:分配内存空间、将对象指向分配的内存空间、初始化对象。这样的话在多线程情况下是有可能产生一种情况:某个线程获取到的sSingleton对象是分配了地址,但是却没有完成实例化的。所以,我们来看下一种方式。

DCL + volatile

public class Singleton {

    private volatile static Singleton sSingleton;

    private Singleton(){}

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

}

为单例成员变量增加了 volatile关键字。volatile关键字的作用主要是:保持内存可见性与防止指令重排序。很显然我们是利用它避免new Singleton()操作的指令重排。

volatile原理浅析

保存内存可见性
Java是通过几种原子操作完成工作内存和主内存的交互:
lock:作用于主内存,把变量标识为线程独占状态。
unlock:作用于主内存,解除独占状态。
read:作用主内存,把一个变量的值从主内存传输到线程的工作内存。
load:作用于工作内存,把read操作传过来的变量值放入工作内存的变量副本中。
use:作用工作内存,把工作内存当中的一个变量值传给执行引擎。
assign:作用工作内存,把一个从执行引擎接收到的值赋值给工作内存的变量。
store:作用于工作内存的变量,把工作内存的一个变量的值传送到主内存中。
write:作用于主内存的变量,把store操作传来的变量的值放入主内存的变量中。

被volatile修饰的变量
read、load、use动作必须连续出现
assign、store、write动作必须连续出现
因此就能够保证变量的值对于不同线程是实时可见的

防止进行指令重排
编译器在生成字节码时,会在指令序列中插入内存屏障来禁止特定类型的处理器重排序。插入内存屏障相当于告诉CPU跟编译器,先于这个命令的比较先执行,而后于这个命令的必须后执行。

volatile没有原子性
volatile似乎是有时候可以代替简单的锁,volatile仅仅用来保证该变量对所有线程的可见性,但不保证原子性。不要将volatile用在getAndOperate场合(这种场合不是原子操作,需要再加锁),仅仅set或者get等操作的场景是适合volatile的,因为非原子操作情况下,代码可能被拆分为多个原子操作,多步操作的情况下就无法保证变量的线程安全,在中间过程中可能在其他线程中被修改。
(参考:https://www.cnblogs.com/rainwang/p/4398488.html

静态内部类

public class Singleton {
    
    private Singleton(){}

    public static Singleton getInstance(){
        return SingletonHolder.mSingleton;
    }

    private static class SingletonHolder{
        private static Singleton mSingleton = new Singleton();
    }

}

这种方式主要利用的ClassLoader加载类只会加载一次的特性以及通过内部静态类去持有单例的对象,保证了单例只会是唯一的,只会初始化一次,同时在调用getInstance方法时才会去加载SingletonHolder类以及实例化单例对象。

Android中用到的单例模式

不管是Android源码,还是各种依赖库框架都经常会使用到单例模式。

EventBus#getDafult()

  private static volatile EventBus defaultInstance;
  public static EventBus getDefault() {
    if (defaultInstance == null) {
        synchronized (EventBus.class) {
            if (defaultInstance == null) {
                defaultInstance = new EventBus();
            }
        }
    }
    return defaultInstance;
}

InputMethodManager#getInstance()

    static InputMethodManager sInstance;
    public static InputMethodManager getInstance() {
        synchronized (InputMethodManager.class) {
            if (sInstance == null) {
                try {
                    sInstance = new InputMethodManager(Looper.getMainLooper());
                } catch (ServiceNotFoundException e) {
                    throw new IllegalStateException(e);
                }
            }
            return sInstance;
        }
    }
最后编辑于
©著作权归作者所有,转载或内容合作请联系作者
平台声明:文章内容(如有图片或视频亦包括在内)由作者上传并发布,文章内容仅代表作者本人观点,简书系信息发布平台,仅提供信息存储服务。

推荐阅读更多精彩内容