1 在Android实现轮询功能（客户端定期向服务端发送请求以获取最新的数据技术）
原理：客户端按固定时间（5s，3m，1h）主动向服务器查询数据，适用于实时性要求不高的的场景(天气更新，聊天消息等)
实现方案：
RxJava方案：通过Observable.interval()创建定时任务。
Handler方案：结合postDelayed()实现延迟执行。
协程方案：使用delay()函数实现异步轮询（最优最推荐）
/**
* 在Android开发中，使用kotlin协程实现轮询效果是当前推荐方案，其核心就是优势就是在于非阻塞式挂起和结构化并发管理
*/
class PollingViewModel : ViewModel() {
private var pollingJob: Job? = null
fun startPolling(interval: Long = 5000L) {
pollingJob = viewModelScope.launch {
while (isActive) {
fetchData()//执行轮询任务
delay(interval)
}
}
}
fun stopPolling() {
pollingJob?.cancel()
}
private suspend fun fetchData() {
withContext(Dispatchers.IO) {
//轮询的逻辑 网络请求或数据库操作
}
}
}
然后在Activity中使用：
override fun onStart() {
super.onStart()
viewModel?.startPolling(3000)
}
override fun onStop() {
super.onStop()
viewModel?.stopPolling()
}
2 安卓开发中实现延迟操作调度常用方法：
方法2.1 Handler+postDelayed
优点：简单易用，适合短时间延迟任务。
在主线程运行，不用担心线程安全问题，
var handler = Handler(Looper.getMainLooper())
var runnable: Runnable = object : Runnable {
override fun run() {
handler.postDelayed(this, 1000)
}
}
//开启延迟/定时任务
handler.postDelayed(runnable, 1000)
//停止定时任务
handler.removeCallbacks(runnable)
方法2.2 RxJava+Interval
使用RxJava的Observable.Interval或Observable.timer方法创建定时流适用于响应式编程场景，实时数据刷新，事件轮询。
Observable.interval(1, TimeUnit.SECONDS) // 每秒发射一次
.observeOn(Schedulers.io()) // 在后台线程执行
.subscribe(time -> {
Log.d("tyl","定时任务执行: " + time + "秒");
});
方法2.3 Kotlin Coroutine+delay
使用Kotlin的delay实现定时器，适用于安卓开发中轻量级异步定时任务。
优点：非阻塞，性能强，协程整合良好。
suspend fun doAction() {
val job = lifecycleScope.launch{
while (isActive){
Log.d("tanyonglin", "Coroutine working...")
delay(1000) //每秒执行一次
}
}
delay(5000) //5s后取消任务
job.cancelAndJoin()
}
2 在kotlin中等待多个异步任务结果再执行下一步操作。
fun main() {
lifecycleScope.launch {
Log.d("tanyl", "开始执行任务")
val task1Deferred = async { performTask1() }
val task2Deferred = async { performTask2() }
val task3Deferred = async { performTask3() }
val result1Deferred = task1Deferred.await()
val result2Deferred = task2Deferred.await()
val result3Deferred = task3Deferred.await()
Log.d("tanyl", "完成任务的返回结果 $result1Deferred $result2Deferred $result3Deferred")
}
}
private suspend fun performTask1(): String {
delay(1000) // 模拟耗时操作
Log.d("tanyl", "执行任务1完成")
return "Task 1 Done"
}
private suspend fun performTask2(): String {
delay(500) // 模拟耗时操作
Log.d("tanyl", "执行任务2完成")
return "Task 2 Done"
}
private suspend fun performTask3(): String {
delay(2000) // 模拟耗时操作
Log.d("tanyl", "执行任务3完成")
return "Task 3 Done"
}
在lifecycleScope作用域中启动三个子协程，调用async()启动子协程不会挂起父协程，而是立即返回一个Deferred对象，直到调用await()方法协程的执行才会被挂起，当父协程在多个Deferred对象上被挂起时，只有当它们都恢复后，协程才继续执行。这样就实现了等待多个并行的异步结果。
或者这么写
val deferredTasks = listOf(
async { performTask1() },
async { performTask2() },
async { performTask3() }
)
val results=deferredTasks.awaitAll()
一样的效果，如果不需要返回结果的话
val deferredTasks = listOf(
async { performTask1() },
async { performTask2() },
async { performTask3() }
)
deferredTasks.joinAll()
