Android多进程应用中如何实现仅在冷启动时执行一次操作？

针对你的多进程场景，要实现冷启动会话内仅执行一次重置操作、对话框只显示一次，这里提供几种可行的方案：

方案一：原子SharedPreferences操作+进程计数 #

核心思路是用SharedPreferences的原子提交操作，确保只有第一个启动的进程完成冷启动重置，同时通过进程计数判断应用是否完全退出，以便下次冷启动重新初始化。

实现步骤： #

1. 在Application类中，启动时更新进程存活计数；
2. 原子检查冷启动初始化标记，未初始化则重置对话框状态并标记已初始化；
3. 监听Activity生命周期，当进程无存活Activity时减少计数，计数为0时重置所有标记。

代码示例： #

class App : Application() {
    private val PREFS_NAME = "multi_process_prefs"
    private val KEY_COLD_START_INIT = "cold_start_done"
    private val KEY_DIALOG_SHOWN = "dialog_shown"
    private val KEY_PROCESS_COUNT = "process_count"

    override fun onCreate() {
        super.onCreate()
        val sp = getSharedPreferences(PREFS_NAME, Context.MODE_PRIVATE)
        val editor = sp.edit()

        // 原子更新进程计数
        val currentCount = sp.getInt(KEY_PROCESS_COUNT, 0)
        editor.putInt(KEY_PROCESS_COUNT, currentCount + 1)
        editor.commit() // 用commit保证原子性

        // 仅第一个进程执行冷启动初始化
        if (!sp.getBoolean(KEY_COLD_START_INIT, false)) {
            editor.putBoolean(KEY_DIALOG_SHOWN, false)
            editor.putBoolean(KEY_COLD_START_INIT, true)
            editor.commit()
        }

        // 监听进程退出
        registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {
            override fun onActivityDestroyed(activity: Activity) {
                val am = getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
                val currentProcess = applicationInfo.processName
                // 检查当前进程是否还有前台Activity
                val hasAliveActivities = am.runningAppProcesses?.any {
                    it.processName == currentProcess && it.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
                } ?: false

                if (!hasAliveActivities) {
                    val exitEditor = sp.edit()
                    val newCount = sp.getInt(KEY_PROCESS_COUNT, 0) - 1
                    exitEditor.putInt(KEY_PROCESS_COUNT, newCount)
                    // 所有进程退出，重置冷启动标记
                    if (newCount == 0) {
                        exitEditor.putBoolean(KEY_COLD_START_INIT, false)
                        exitEditor.putBoolean(KEY_DIALOG_SHOWN, false)
                    }
                    exitEditor.commit()
                }
            }

            // 其他生命周期方法空实现
            override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {}
            override fun onActivityStarted(activity: Activity) {}
            override fun onActivityResumed(activity: Activity) {}
            override fun onActivityPaused(activity: Activity) {}
            override fun onActivityStopped(activity: Activity) {}
            override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {}
        })
    }
}

显示对话框逻辑： #

fun showDialogIfNeeded(context: Context) {
    val sp = context.getSharedPreferences("multi_process_prefs", Context.MODE_PRIVATE)
    if (!sp.getBoolean("dialog_shown", false) && 你的特定条件) {
        AlertDialog.Builder(context)
            .setTitle("提示")
            .setMessage("冷启动仅显示一次的对话框")
            .setPositiveButton("确定") { dialog, _ ->
                dialog.dismiss()
                sp.edit().putBoolean("dialog_shown", true).commit()
            }
            .show()
    }
}

方案二：文件锁实现独占初始化 #

利用文件锁的独占性，确保只有第一个获取到锁的进程执行重置操作，进程退出后锁自动释放，下次冷启动可重新获取。

代码示例： #

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        resetDialogFlagIfColdStart(this)
    }

    private fun resetDialogFlagIfColdStart(context: Context) {
        val lockFile = File(context.filesDir, "cold_start_lock")
        var channel: FileChannel? = null
        try {
            channel = RandomAccessFile(lockFile, "rw").channel
            // 尝试非阻塞获取独占锁
            val lock = channel.tryLock()
            lock?.let {
                val sp = context.getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
                sp.edit().putBoolean("DIALOG_SHOWN", false).commit()
                it.release()
            }
        } catch (e: IOException) {
            e.printStackTrace()
        } finally {
            channel?.close()
        }
    }
}

这种方案无需维护进程计数，逻辑更简洁，但要注意文件权限和异常处理，避免锁泄漏。

方案三：指定主进程执行初始化 #

如果你的场景中，主进程（Process A）一定会在其他进程之前启动，或者允许主进程被拉起，可直接在Application中判断当前进程是否为主进程，仅主进程执行重置操作。

代码示例： #

class App : Application() {
    override fun onCreate() {
        super.onCreate()
        val currentProcessName = getCurrentProcessName(this)
        val mainProcessName = applicationInfo.processName
        if (currentProcessName == mainProcessName) {
            // 仅主进程执行冷启动重置
            val sp = getSharedPreferences("app_prefs", Context.MODE_PRIVATE)
            sp.edit().putBoolean("DIALOG_SHOWN", false).commit()
        }
    }

    private fun getCurrentProcessName(context: Context): String {
        val pid = android.os.Process.myPid()
        val am = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        for (process in am.runningAppProcesses ?: emptyList()) {
            if (process.pid == pid) {
                return process.processName
            }
        }
        return ""
    }
}

注意：如果Activity B被独立启动（主进程未运行），此方案会失效，因为主进程未启动，重置操作不会执行，对话框可能不会显示。

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