什么是设计模式?
设计模式是一套经过验证的软件设计解决方案,用于解决软件开发中的常见问题,提高代码的可重用性、可维护性和可扩展性。
这是设计模式的定义。简单来说,它是一套能够解决特定场景问题的开发思想------它是一套思想,而不是固定的模板代码,只要思想一致,就可以认为是同一种模式。
接下来,我们从最常见的单例设计模式开始讲起。
单例设计模式的常见实现
单例设计模式能够保证一个类在整个程序中只有一个实例,并对外提供一个入口来获取该实例。比如日志类、线程池、各类管理类都很适合使用这个模式。
下面介绍几种比较常见的实现方式,先从最简单的饿汉式开始。
饿汉式:类加载即创建
怎么实现呢?
- 私有化构造函数,防止外部创建实例。
- 内部提供静态方法,供外部调用获取实例。
像这样(这里先展示 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(); 在底层其实会分为三步:
- 在内存中开辟一块空间,用来存放
Singleton对象的数据。 - 初始化对象,对内存空间里的属性赋值。
- 把
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();