likes
comments
collection
share

【Android每日一问】手撸单例以及优缺点分析

作者站长头像
站长
· 阅读数 36

饿汉单例

public class Singleton {
    private static Singleton instence = new Singleton();

    private Singleton() {

    }
    
    public static Singleton getInstance() {
        return instence;
    }
}
  • 在类被加载进入内存的时候就创建单一的instance对象,这种模式比较消耗内存资源。
  • 优点：获取对象的速度快；避免了多线程的同步问题。
  • 缺点：类加载过程慢。

饿汉变种单例（静态内部类）

public class Singleton {


    private Singleton() {

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

    public static Singleton getInstance() {
        return SingletonHolder.INSTANCE;
    }
}
  • 这种单例模式在第一次类加载时并不会初始化，只有在第一次调用getInstance()时虚拟机加载SingletonHolder并初始化SingleTon实例，也是线程安全的，也是推荐使用的。
  • 优点：线程安全，节约资源
  • 缺点：第一次加载时反应稍慢

为什么静态内部类是线程安全的？

首先了解一下静态内部类的优点：

  • 外部类加载时并不需要立即加载内部类
  • 内部类不被加载则不去初始化INSTANCE，故而不占内存
  • 具体来说当SingleTon第一次被加载时，并不需要去加载SingleTonHoler，只有当getInstance()方法第一次被调用时，使用INSTANCE的时候,才会导致虚拟机加载SingleTonHoler类。

那么是如何实现线程安全的？

在类加载的最后一个阶段：类的初始化，本质就是执行类构造器的<clinit>方法。<clinit>是由javac编译器生成的，JVM内部会保证一个类的<clinit>在多线程环境下被正确的加锁同步，简单来说就是如果有多个线程同时去做类的初始化工作，那么只有一个线程会执行<clinit>方法，其他线程会阻塞，直到执行完，其他线程唤醒，但是不会再次执行<clinit>方法。也就是说，一个类只会初始化一次。

再看上面的单例可以简单看出，这里对INSTANCE的赋值操作，编译之后实际上就是一个<clinit>代码，当我们执行getInstance()时，会导致SingletonHolder类的加载，类加载的最后会执行类的初始化操作，即使在多线程下<clinit>也只会被执行一次，所以他只有一个实例存在，从而避免多线程的问题。

懒汉单例

public class Singleton{
    private static Singleton instance= null;
    
    private static Singleton(){}
    
    public static Singleton getInstance(){
        if(instance==null){
            instance = new Singleton();
        }
        return instence;       
    }
}
  • 这种模式只有在需要使用的时候才进行实例的初始化，在单线程下能够非常好的工作，但是在多线程下存在线程安全问题。
  • 优点：节约资源
  • 缺点：第一次加载时需要实例化，反应稍慢；多线程下不能正常工作

懒汉+线程安全单例

public class Singleton{
    private static Singleton instance =null;
    
    private static Singleton(){}
    
    public static synchronized getInstance(){
        if(instance==null){
            instance =new Singleton();
        }
        return instance;
    }
}
  • 这种模式为了解决多线程问题，采用了对函数进行同步的方式，但是比较浪费资源，因为每次都要进行同步检查，而实际中真正需要检查只是第一次实例化的时候。
  • 优点：在多线程下可以安全的使用
  • 缺点：造成不必要的同步开销

枚举单例

public enum Singleton{
    INSTANCE
}
  • 这种模式基本没人在用，知道就行。

双重校验锁单例（DCL）

public class Singleton{
    private static volatile Singleton instance=null;
    private static Singleton(){}
    public static Singleton getInstance(){
        if(instance==null){
            synchronized(Singleton.class){
                if(instance==null){
                    instance=new Singleton();
                }
            }
        }
        return instance;
    }
}
  • 第一次判空是减少不必要的同步开销，也是对上面写法的改进；第二次判空是创建实例对象。注意这里使用了volatile关键字。
  • 这种模式既解决了资源浪费的问题，也解决了多线程的问题，建议使用。
  • 优点：资源利用率高，线程安全。
  • 缺点：第一次加载时反应稍慢，在高并发环境下有缺陷。
转载自:https://juejin.cn/post/6950209018946125855
评论
请登录