单实例Activity的Handler执行管理：如何仅保留活跃实例的Handler

你的问题核心是singleInstance模式的Activity出现了短暂双实例的生命周期异常，导致两个实例的Handler都触发了延迟任务。以下是几种有效的解决方法：

方法一：在onDestroy中清理当前实例的Handler回调 #

每个Activity实例的handler是独立的成员变量，在旧实例销毁时，直接清理自己的Handler任务，不会影响新实例的任务。

Handler handler;

@Override
protected void onStart() {
    super.onStart();
    handler = new Handler();
    handler.postDelayed(() -> {
        // 执行操作前先判断Activity是否存活
        if (!isFinishing() && !isDestroyed()) {
            // 这里写你的业务逻辑
        }
    }, 5000);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (handler != null) {
        // 移除当前实例Handler的所有回调和消息
        handler.removeCallbacksAndMessages(null);
        handler = null; // 避免内存泄漏
    }
}

原理：旧实例销毁时，onDestroy会被调用，此时清理自己的Handler任务，新实例的Handler不受任何影响。加上Activity存活状态判断，能进一步防止极端情况下的无效操作。

方法二：用弱引用绑定Handler与Activity #

如果担心Handler持有Activity引用导致内存泄漏，可以用弱引用封装Handler，同时在回调里判断Activity是否存活：

// 静态内部类避免持有外部类强引用
private static class MyHandler extends Handler {
    private WeakReference<YourActivity> activityRef;

    MyHandler(YourActivity activity) {
        activityRef = new WeakReference<>(activity);
    }
}

private MyHandler handler;

@Override
protected void onStart() {
    super.onStart();
    handler = new MyHandler(this);
    handler.postDelayed(() -> {
        YourActivity currentActivity = handler.activityRef.get();
        // 只有Activity存活且未销毁时才执行操作
        if (currentActivity != null && !currentActivity.isFinishing() && !currentActivity.isDestroyed()) {
            // 这里写你的业务逻辑
        }
    }, 5000);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (handler != null) {
        handler.removeCallbacksAndMessages(null);
        handler = null;
    }
}

原理：弱引用不会阻止Activity被GC回收，旧实例销毁后，activityRef会变为null，回调里的操作自然不会执行。

方法三：用静态变量标记活跃实例 #

利用singleInstance最终只会有一个活跃实例的特性，用静态变量记录当前活跃的Activity，Handler执行时只处理当前活跃实例的任务：

private static YourActivity sActiveInstance;
private Handler handler;

@Override
protected void onStart() {
    super.onStart();
    sActiveInstance = this; // 更新为当前活跃实例
    handler = new Handler();
    handler.postDelayed(() -> {
        // 只有当前实例是活跃实例时才执行操作
        if (sActiveInstance == YourActivity.this) {
            // 这里写你的业务逻辑
        }
    }, 5000);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    if (sActiveInstance == this) {
        sActiveInstance = null;
    }
    if (handler != null) {
        handler.removeCallbacksAndMessages(null);
        handler = null;
    }
}

原理：每次onStart都会把静态变量指向当前实例，旧实例的回调触发时，sActiveInstance已经指向新实例，所以不会执行操作。

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