如何避免重复创建Handler，实现Android应用全局单例Handler？

嘿，这个问题挺典型的——每次进入MainActivity都新建Handler确实会造成不必要的实例浪费，而且还可能带来内存泄漏风险。下面给你几个靠谱的实现全局唯一Handler的方法，顺便帮你规避踩坑：

方案一：单例模式封装Handler #

我们可以写一个单例类来持有Handler实例，注意一定要用Application的MainLooper，这样能保证Handler运行在主线程，而且整个应用生命周期内只有一个实例：

class GlobalHandler private constructor(looper: Looper) : Handler(looper) {
    companion object {
        @Volatile
        private var instance: GlobalHandler? = null

        // 传入Application来获取主线程Looper，避免上下文泄漏
        fun getInstance(app: Application): GlobalHandler {
            return instance ?: synchronized(this) {
                instance ?: GlobalHandler(app.mainLooper).also { instance = it }
            }
        }
    }
}

在MainActivity里这么用：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // 获取全局唯一的Handler实例
    val globalHandler = GlobalHandler.getInstance(application)
    // 你的延迟任务逻辑...
}

方案二：把Handler放在自定义Application类里 #

Application是整个应用的入口，生命周期和应用一致，所以把Handler放在这里也能保证全局唯一：

首先自定义Application类：

class MyApplication : Application() {
    lateinit var appHandler: Handler

    override fun onCreate() {
        super.onCreate()
        // 初始化主线程Handler
        appHandler = Handler(mainLooper)
    }
}

然后在AndroidManifest.xml里配置这个Application：

<application
    android:name=".MyApplication"
    <!-- 其他配置 -->
    >
</application>

之后在MainActivity里获取：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    val appHandler = (application as MyApplication).appHandler
    // 执行你的任务...
}

重要提醒：规避内存泄漏！ #

你原来的代码里用了匿名内部类的Runnable，这个Runnable会隐式持有MainActivity的引用，如果Activity销毁后Handler还在执行延迟任务，就会导致Activity无法被GC回收，造成内存泄漏。

解决方法有两种：

1. 静态内部类+弱引用：

// 静态内部类，不会持有外部Activity的引用
private class MoneyUpdateRunnable(private val activityRef: WeakReference<MainActivity>) : Runnable {
    override fun run() {
        val activity = activityRef.get()
        activity?.let {
            try {
                it.player.money += it.player.cps
                it.player.moneyEarned += it.player.cps
                it.updateText()
                it.save()
            } catch (e: Exception) {
                println("ERROR: ${e.localizedMessage}")
            }
            // 继续循环执行
            it.handler.postDelayed(this, 1000)
        }
    }
}

在Activity里启动任务：

globalHandler.postDelayed(MoneyUpdateRunnable(WeakReference(this)), 0)

2. 改用协程（更推荐）：
   现在Android开发更推荐用协程来替代Handler做延迟/循环任务，协程会自动和生命周期绑定，避免内存泄漏：

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // 使用lifecycleScope，Activity销毁时会自动取消协程
    lifecycleScope.launch {
        while (isActive) {
            delay(1000)
            try {
                player.money += player.cps
                player.moneyEarned += player.cps
                updateText()
                save()
            } catch (e: Exception) {
                println("ERROR: ${e.localizedMessage}")
            }
        }
    }
}

这种方式不需要手动管理Handler，代码更简洁还安全。

内容的提问来源于stack exchange，提问作者Tad