Android/Kotlin中每5秒执行网络请求的最优实现方案咨询

首先明确：CountDownTimer并不适合你的场景。它本质是一次性倒计时组件，虽然可以在onFinish()里手动重启计时器来实现重复，但这种方式不仅代码冗余，还容易引发内存泄漏（比如Activity销毁后旧计时器实例仍在运行），也无法很好地和Android生命周期绑定。

以下是几种更合适的实现方案：

1. Kotlin协程（推荐，适用于UI相关的周期性任务） #

协程是Kotlin官方推荐的异步编程方案，结合生命周期感知的CoroutineScope（如lifecycleScope或viewModelScope），可以自动在组件销毁时取消任务，完美避免内存泄漏。

在Activity/Fragment中使用： #

// 在onCreate或onViewCreated中启动
lifecycleScope.launch {
    while (isActive) { // isActive会自动感知组件生命周期，销毁时变为false
        try {
            // 执行网络请求（建议将网络请求封装到Repository层）
            val newData = apiService.getListData()
            // 更新UI列表（协程在主线程执行，可直接操作UI）
            recyclerViewAdapter.updateData(newData)
        } catch (e: Exception) {
            // 处理网络异常，比如Toast提示
            Toast.makeText(context, "更新失败：${e.message}", Toast.LENGTH_SHORT).show()
        }
        delay(5000) // 等待5秒后再次执行
    }
}

在ViewModel中使用（更推荐，与UI解耦）： #

将数据请求逻辑放在ViewModel里，通过LiveData通知UI更新：

class ListViewModel : ViewModel() {
    private val _listData = MutableLiveData<List<Item>>()
    val listData: LiveData<List<Item>> = _listData

    init {
        startPeriodicUpdate()
    }

    private fun startPeriodicUpdate() {
        viewModelScope.launch {
            while (isActive) {
                try {
                    val newData = apiService.getListData()
                    _listData.postValue(newData)
                } catch (e: Exception) {
                    // 异常处理，可通过LiveData通知UI显示错误状态
                }
                delay(5000)
            }
        }
    }
}

2. WorkManager（适用于需要后台持续执行的场景） #

如果你的需求是即使App退到后台，仍要保持每5秒更新数据，那么WorkManager是更好的选择。它会根据系统状态调度任务，保证任务的可靠性。

步骤1：创建Worker类 #

class ListUpdateWorker(
    context: Context,
    params: WorkerParameters
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            val apiService = ApiService.getInstance()
            val newData = apiService.getListData()
            // 将数据保存到本地（如DataStore、Room），UI通过监听本地数据变化更新
            DataStoreManager.saveListData(newData)
            Result.success()
        } catch (e: Exception) {
            // 任务失败时，可选择重试或标记失败
            Result.retry()
        }
    }
}

步骤2：调度周期性任务 #

// 在Activity或Application中启动任务
val periodicWorkRequest = PeriodicWorkRequestBuilder<ListUpdateWorker>(
    repeatInterval = 5,
    repeatIntervalTimeUnit = TimeUnit.SECONDS
).build()

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "ListUpdateTask",
    ExistingPeriodicWorkPolicy.KEEP, // 如果已有同名任务，保留现有任务
    periodicWorkRequest
)

3. Handler+Runnable（传统方案，不推荐） #

这是早期Android常用的方式，但需要手动处理生命周期，容易引发内存泄漏，除非你对内存管理有足够的经验：

private val handler = Handler(Looper.getMainLooper())
private val updateRunnable = object : Runnable {
    override fun run() {
        // 执行网络请求（注意：网络请求必须放在子线程）
        Thread {
            try {
                val newData = apiService.getListData()
                // 回到主线程更新UI
                handler.post {
                    recyclerViewAdapter.updateData(newData)
                }
            } catch (e: Exception) {
                // 异常处理
            }
            // 5秒后再次执行
            handler.postDelayed(this, 5000)
        }.start()
    }
}

// 在onStart中启动
override fun onStart() {
    super.onStart()
    handler.post(updateRunnable)
}

// 在onStop中停止，避免内存泄漏
override fun onStop() {
    super.onStop()
    handler.removeCallbacks(updateRunnable)
}

关键注意事项 #

• 网络请求必须在后台线程：协程和WorkManager已经默认处理了后台执行，Handler方案需要手动创建线程。
• 异常处理不可少：网络请求可能失败，要捕获异常避免任务终止。
• 生命周期绑定：确保在组件销毁时停止任务，协程的lifecycleScope/viewModelScope会自动处理，Handler需要在onStop/onDestroy中移除回调，WorkManager可在不需要时取消任务。

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