如何让秒表App在完全关闭、销毁或设备重启/关机后持续运行？

你的思路完全正确！要实现这种「离线也能继续计时」的效果，我们不需要让App真的在后台一直跑（这既不现实也浪费资源），而是通过记录关键时间点，用系统绝对时间来计算差值。下面是具体的实现方案：

核心逻辑 #

我们需要存储三个关键数据：

• totalSeconds：秒表累计运行的总时长（秒）
• lastUpdateTime：上次更新这个累计时长时的系统时间戳（毫秒，用System.currentTimeMillis()获取）
• isRunning：秒表最后一次的运行状态（是否在计时中）

当App重新打开或设备重启后：

1. 如果秒表之前是运行状态，计算当前时间与lastUpdateTime的差值，把这个差值转换成秒加到totalSeconds上，然后继续计时
2. 如果是暂停状态，直接用totalSeconds恢复显示即可

具体实现步骤 #

1. 使用SharedPreferences存储数据 #

SharedPreferences是Android中轻量级的存储方案，适合保存这种小量的状态数据。

2. 修改MainActivity代码 #

下面是完整的修改后的代码，关键部分已添加注释：

package com.study.meter;
import androidx.appcompat.app.AppCompatActivity;
import android.view.View;
import android.os.Bundle;
import android.widget.TextView;
import android.widget.Button;
import android.os.Handler;
import java.util.Locale;
import android.content.SharedPreferences;

public class MainActivity extends AppCompatActivity {
    public TextView StopWatch;
    public boolean isStopWatchRunning = false;
    public int totalSeconds = 0;
    private long lastUpdateTime = 0;
    private Handler handler;
    // SharedPreferences相关常量
    private static final String PREFS_NAME = "StopWatchPrefs";
    private static final String KEY_TOTAL_SECS = "totalSeconds";
    private static final String KEY_LAST_UPDATE = "lastUpdateTime";
    private static final String KEY_IS_RUNNING = "isRunning";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 隐藏ActionBar
        this.getSupportActionBar().hide();
        StopWatch = findViewById(R.id.StopWatch);
        handler = new Handler(); // 初始化Handler为成员变量，避免重复创建

        // 从SharedPreferences恢复之前的状态
        loadSavedState();

        // 如果之前秒表是运行状态，恢复计时
        if (isStopWatchRunning) {
            resumeStopWatch();
        } else {
            // 暂停状态直接更新显示
            updateDisplay();
        }
    }

    // 读取保存的状态
    private void loadSavedState() {
        SharedPreferences prefs = getSharedPreferences(PREFS_NAME, MODE_PRIVATE);
        totalSeconds = prefs.getInt(KEY_TOTAL_SECS, 0);
        lastUpdateTime = prefs.getLong(KEY_LAST_UPDATE, System.currentTimeMillis());
        isStopWatchRunning = prefs.getBoolean(KEY_IS_RUNNING, false);
    }

    // 保存当前状态到SharedPreferences
    private void saveCurrentState() {
        SharedPreferences prefs = getSharedPreferences(PREFS_NAME, MODE_PRIVATE);
        SharedPreferences.Editor editor = prefs.edit();
        editor.putInt(KEY_TOTAL_SECS, totalSeconds);
        editor.putLong(KEY_LAST_UPDATE, lastUpdateTime);
        editor.putBoolean(KEY_IS_RUNNING, isStopWatchRunning);
        editor.apply();
    }

    // 恢复计时：计算从上次暂停到现在的差值，更新总时长
    private void resumeStopWatch() {
        long currentTime = System.currentTimeMillis();
        // 计算差值（毫秒转秒）
        long timeDiff = (currentTime - lastUpdateTime) / 1000;
        totalSeconds += timeDiff;
        lastUpdateTime = currentTime;
        // 开始计时循环
        startTimerLoop();
    }

    // 启动计时循环
    private void startTimerLoop() {
        handler.post(new Runnable() {
            @Override
            public void run() {
                if (isStopWatchRunning) {
                    long currentTime = System.currentTimeMillis();
                    // 计算从上一次更新到现在的秒数差值
                    long timeDiff = (currentTime - lastUpdateTime) / 1000;
                    if (timeDiff > 0) {
                        totalSeconds += timeDiff;
                        lastUpdateTime = currentTime;
                        updateDisplay();
                    }
                    // 每1000ms更新一次
                    handler.postDelayed(this, 1000);
                }
            }
        });
    }

    // 更新秒表显示
    private void updateDisplay() {
        int hours = totalSeconds / 3600;
        int minutes = (totalSeconds % 3600) / 60;
        int secs = totalSeconds % 60;
        String time = String.format(Locale.getDefault(), "%d:%02d:%02d", hours, minutes, secs);
        StopWatch.setText(time);
    }

    public void StartorStop(View v) {
        Button sv = (Button)v;
        if(isStopWatchRunning) {
            // 停止计时
            isStopWatchRunning = false;
            sv.setText("Start");
            handler.removeCallbacksAndMessages(null); // 移除所有Handler的回调
            saveCurrentState(); // 保存状态
        }else {
            // 开始计时
            isStopWatchRunning = true;
            sv.setText("Stop");
            lastUpdateTime = System.currentTimeMillis(); // 更新当前时间戳
            startTimerLoop();
            saveCurrentState(); // 保存状态
        }
    }

    // App销毁时保存状态
    @Override
    protected void onDestroy() {
        super.onDestroy();
        saveCurrentState();
        // 移除Handler回调，避免内存泄漏
        handler.removeCallbacksAndMessages(null);
    }
}

关键说明 #

• 将Handler设为成员变量，避免每次点击按钮都创建新的Handler，防止多个计时线程同时运行
• 在onDestroy方法中保存状态，确保App被销毁（包括用户关闭、系统回收）时数据不会丢失
• 恢复计时时，通过计算系统时间戳的差值来补全离线期间的时长，完全不需要后台持续运行
• 即使设备关机重启，只要系统时间是正确的，这个逻辑依然有效（因为时间戳是绝对时间）

这样修改后，你的秒表就能在App关闭、销毁甚至设备重启后，准确恢复到正确的计时状态啦！

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