单例设计模式:从 Java/Kotlin 实现到 Android 实战

什么是设计模式?

设计模式是一套经过验证的软件设计解决方案,用于解决软件开发中的常见问题,提高代码的可重用性、可维护性和可扩展性。

这是设计模式的定义。简单来说,它是一套能够解决特定场景问题的开发思想------它是一套思想,而不是固定的模板代码,只要思想一致,就可以认为是同一种模式。

接下来,我们从最常见的单例设计模式开始讲起。

单例设计模式的常见实现

单例设计模式能够保证一个类在整个程序中只有一个实例,并对外提供一个入口来获取该实例。比如日志类、线程池、各类管理类都很适合使用这个模式。

下面介绍几种比较常见的实现方式,先从最简单的饿汉式开始。

饿汉式:类加载即创建

怎么实现呢?

  1. 私有化构造函数,防止外部创建实例。
  2. 内部提供静态方法,供外部调用获取实例。

像这样(这里先展示 Java 代码):

java 复制代码
public class Singleton {
    // 1. 私有化构造函数,且只有一个构造函数
    private Singleton() {
    }

    // 2. 内部持有的实例
    private static final Singleton instance = new Singleton();

    // 3. 提供方法获取内部持有的实例
    public static Singleton getInstance() {
        return instance;
    }
}

这样就完成了一个最简单的单例,也就是饿汉式------在类加载时就直接创建好实例。

这种方式简单,天生线程安全。不过也有缺点:只要这个类被加载(比如调用了类的其他静态方法或访问了静态字段),哪怕没有调用过 getInstance(),实例也会被提前创建出来。如果实例初始化的开销较大,就可能会造成内存浪费,或者拖慢程序的启动速度。

懒汉式与双重检查锁(DCL):按需加载

既然这样,我们可以变为延时加载:只有真正要用的时候,才去创建实例。像这样:

java 复制代码
public class Singleton {
    private Singleton() {
    }

    private static Singleton instance;

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

这就是基础的懒汉式单例,但它有一个 Bug:在多线程并发的场景下,可能会有不止一个线程同时进入到 if 语句中,从而创建出多个实例。

如何解决呢?最直接的办法就是往 getInstance 方法上加锁:

java 复制代码
public static synchronized Singleton getInstance() {
    if (instance == null) {
        instance = new Singleton();
    }
    return instance;
}

不过给整个方法加锁的性能不佳,每次获取实例都要经过同步锁。所以实际开发中一般会使用 DCL 双重检查锁来解决这个问题:

关于双重检查锁 (DCL) 的更多细节,可以看我的这篇博客:Java 多线程指南:从基础用法到线程安全

java 复制代码
// volatile 防止指令重排
private static volatile Singleton instance;

private static final Object instanceLock = new Object();

public static Singleton getInstance() {
    if (instance == null) {
        synchronized (instanceLock) {
            if (instance == null) {
                // 内层的判断,是为了防止多个线程先后拿到锁,导致实例重复创建
                instance = new Singleton();
            }
        }
    }
    return instance;
}

这种方式兼顾了效率和线程安全,通常只有第一次获取实例时会用到锁,后续调用都会直接跳过最外层的判断。

为什么 DCL 必须加 volatile?

注意:synchronized 虽然能保证同步块内的互斥执行和可见性,但是无法禁止代码块内部的指令重排。最外层的 if(instance == null) 不在锁内的代码块中,所以必须要给 instance 加上 volatile 关键字禁止指令重排,来保证有序性。

当然 volatile 关键字也能保证可见性,此时它的作用主要是有序性。

那为什么指令重排会出现问题呢?

因为 instance = new Singleton(); 在底层其实会分为三步:

  1. 在内存中开辟一块空间,用来存放 Singleton 对象的数据。
  2. 初始化对象,对内存空间里的属性赋值。
  3. 把 instance 变量指向这块内存空间。

在 JVM 中,第二步和第三步的执行顺序并不固定。如果发生了重排,就可能会出现这种情况:线程 A 执行完了第 1 步和第 3 步(此时 instance 已经不为空,但对象还没初始化完),另一个线程在最外层判断 instance != null,就直接将其返回。结果调用方拿到了一个"半成品"对象,使用起来就会出问题。

静态内部类:优雅的懒加载

静态内部类也是一种常用的单例写法:

java 复制代码
public class Singleton {
    private Singleton() {
    }

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

    public static Singleton getInstance() {
        return InnerHolder.INSTANCE;
    }
}

这同样属于懒加载 ------只有调用 getInstance() 时,InnerHolder 类才会被加载,进而创建实例。类加载过程由 JVM 保证线程安全,而且没有任何的锁开销。

枚举单例:最安全的实现

还有公认最安全的枚举单例:

java 复制代码
public enum Singleton {
    INSTANCE;

    // 业务代码
}

它和饿汉式类似,但有两个优势:

  • 防反射破坏:JDK 底层在反射创建对象时会专门进行校验,禁止通过反射创建枚举实例。
  • 防反序列化破坏 :常规的反序列化中,会通过底层反射机制,绕过当前类的私有构造函数,直接创建一个新对象。而枚举的序列化经过了 JVM 的特殊处理,序列化时只保存枚举常量名称,反序列化时会直接通过 Enum.valueOf() 从枚举常量表中取出已有对象,不会创建新实例。

Kotlin 中的单例:object 与 by lazy

当然在 Kotlin 中,最简单的单例写法就是 object 类名:

kotlin 复制代码
object KotlinSingleton {
    val now = System.currentTimeMillis()
}

这是啥意思呢?

直接使用 IDE 的工具查看字节码,再点击反编译,可以看到它对应的 Java 代码类似这样:

java 复制代码
public final class KotlinSingleton {
   @NotNull
   public static final KotlinSingleton INSTANCE = new KotlinSingleton();
   private static final long now = System.currentTimeMillis();

   private KotlinSingleton() {
   }

   public final long getNow() {
      return now;
   }
}

可以看出 object 本质上就是饿汉式,编译器会自动为当前类生成一个 INSTANCE 静态字段。类似的还有 companion object(伴生对象),有兴趣可以自己反编译字节码看看。

另外,如果要在 Kotlin 中实现懒加载 单例,不要去照搬 Java 的写法,看起来会非常别扭。直接配合 companion object 和 by lazy 就够了:

kotlin 复制代码
class KotlinLazySingleton private constructor() {
    companion object {
        // by lazy 默认采用的 SynchronizedLazyImpl,底层就是双重检查锁(DCL)
        val instance: KotlinLazySingleton by lazy {
            KotlinLazySingleton()
        }
    }
}

Android 实战:封装一个全局 ToastManager

最后,我们用单例模式来封装一个 Toast 管理类。

需求是:支持在子线程中安全调用,且连续点击触发多次 Toast 时只显示最新的一条------也就是在下一条消息显示前,取消上一条就行。

java 复制代码
public class ToastManager {
    private ToastManager() {
    }

    private static volatile ToastManager mInstance;
    private static final Object mInstanceLock = new Object();

    public static ToastManager getInstance() {
        if (mInstance == null) {
            synchronized (mInstanceLock) {
                if (mInstance == null) {
                    mInstance = new ToastManager();
                }
            }
        }
        return mInstance;
    }

    // 以上为单例实现

    private Context mAppContext;
    private Toast mToast;
    private final Handler mMainHandler = new Handler(Looper.getMainLooper());

    public void init(Context context) {
        if (context != null) {
            mAppContext = context.getApplicationContext();
        }
    }

    private boolean isMainThread() {
        return Looper.myLooper() == Looper.getMainLooper();
    }

    public void show(String message, int duration) {
        if (mAppContext == null) {
            throw new IllegalStateException("ToastManager is not initialized.");
        }
        show(mAppContext, message, duration);
    }

    public void show(Context context, String message, int duration) {
        if (context == null) {
            return;
        }
        // 统一转为 ApplicationContext,防止 mToast 间接持有 Activity 导致内存泄漏
        Context appContext = context.getApplicationContext();
        if (!isMainThread()) {
            mMainHandler.post(() -> showInternal(appContext, message, duration));
        } else {
            showInternal(appContext, message, duration);
        }
    }

    private void showInternal(Context appContext, String message, int duration) {
        if (mToast != null) {
            mToast.cancel();
        }
        mToast = Toast.makeText(appContext, message, duration);
        mToast.show();
    }

    /**
     * 取消当前正在显示或排队等待显示的 Toast
     */
    public void cancel() {
        mMainHandler.removeCallbacksAndMessages(null);
        if (isMainThread()) {
            cancelInternal();
        } else {
            mMainHandler.post(this::cancelInternal);
        }
    }

    private void cancelInternal() {
        if (mToast != null) {
            mToast.cancel();
            mToast = null;
        }
    }
}

使用示例:

java 复制代码
public class DemoApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        ToastManager.getInstance().init(this);
    }
}
java 复制代码
new Thread(() -> {
    ToastManager.getInstance().show("Hello, World!", Toast.LENGTH_SHORT);
}).start();
相关推荐
FungLeo1 小时前
FengCMS · PHP+MySQL 升级实录 · 危险默认值之殇:root/123456、认证码 8888 写进配置加载器
android·mysql·php·安全加固·fengcms
yz_aiks1 小时前
Termux 使用教程:把安卓手机变成随身 Linux(装 Python、SSH 远程、跑自动化脚本)
android·linux·python·智能手机·ssh·termux
booboosui9 小时前
编号没变,消息还是来了:Mac 端通知读取漏第二条的原因
android
hai_android1 天前
一行 asLiveData,背后是一座生命周期的桥
android·java·kotlin
阿杰m1 天前
Android源码第二十三章:Telephony、RIL 与 IMS——来电怎么到应用?
android
booboosui1 天前
没人认领 .md:安卓把报告交给了音乐播放器打开
android
用户60709759149061 天前
AOSP 14 OTA 升级指导(四):update_engine 内部机制——Action 流水线与写盘
android
恋猫de小郭2 天前
Jetpack Compose 1.13 发布,憋了这么久终有交代了
android·前端·flutter
JMchen1232 天前
【Android 性能优化实战 60 讲】12 异步 Inflate 实战与痛击:源码拆解原生瓶颈,手写增强版布局预加载框架
android·性能优化·实战·启动优化·异步inflate·x2c