@

目录

• 前言
• 一、直接上例子
  • 1.延时任务.
  • 2.异步任务
  • 3.并行任务:
  • 4.定时任务:
• 总结

前言

你还在用 Hanlder + Message? 或者 AsyncTask? 你还在用 Rxjava?
有人说Rxjava和Coroutine是从不同维度解决异步, 并且Rxjava的强大不止于异步问题.
好吧, 管它呢. 让我们拥抱 Coroutine(协程) 吧.

协程的篇幅有点长, 需要自己编写大量的测试例子. 从入门到都学完, 难度还是挺大的. 所以:我们直接把例子摆出来. 至于其他的, 我们从浅到深,日后..日后..再说 [奸笑]

Kotlin中文站: 请看官网


准备:
lifecycle 都有吧? 例子中需要用到 lifecycleScope;

//coroutines: 协程
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3"
//coroutines for Android
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3'

//lifecycle
implementation 'androidx.lifecycle:lifecycle-runtime-ktx:2.2.0'

没有lifecycle 怎么办? 当页面销毁时,那些延时任务, 例如Handler, 网络请求 啥的, 需要及时关闭, 它们会影响 Activity 的及时销毁, 带来内存泄漏的风险. 协程也是如此.

此时我们必须自己管理协程的作用域; 所以最好还是用 lifecycleScope.

//自己定义作用域, 页面销毁时, 取消协程.  替换lifecycleScope即可;
val mainScope = MainScope()
override fun onDestroy(){
    super.onDestroy()
    mainScope.cancel()
}

什么是协程作用域呢? 类似于生命周期, 当页面销毁时, 协程应当随之停止.

提示：以下是本篇文章正文内容，下面案例可供参考

---

一、直接上例子

协程能干嘛? 延时任务, 异步任务, 定时任务, 并行任务, 协程+Retrofit. 异步流? 通道?

1.延时任务.

比较常见的业务场景, 几秒钟后执行...

还记得handler怎么写吗? 定义 Handler 实现类, 然后

mHandler.sendMessageDelayed()
//或者
mHandler.postDelayed(Runnable{...})

使用协程:

doDelayed()

fun doDelayed() = lifecycleScope.launch {
    delay(2000L)	//协程挂起2秒
    binding.tvTitle.text = "变变变, 我是百变小魔女"
}

• lifecycleScope: 默认主线程. 它会监听Activity生命周期, 不需要手动 cancel()
• launch: 非阻塞形式启动协程.
• delay(2000): 挂起协程, 2秒后恢复.

然后封装一下:

//执行延时任务
fun CoroutineScope.doDelayed(timeMillis: Long, block: suspend () -> Unit) = this.launch {
    delay(timeMillis)
    block.invoke()
}

//使用
lifecycleScope.doDelayed(2000L){
    binding.tvTitle.text = "变变变, 我是百变小魔女"
}

2.异步任务

在子线程执行任务, 完事回调主线程
代码如下：

doOnBack()

// 模拟子线程中执行了2秒钟的任务,
private fun doOnBack() = lifecycleScope.launch {
    val result = withContext(Dispatchers.IO){
        delay(2000) // 假装努力干活中..
        "变变变, 我是百变小魔女"
    }
    binding.tvTitle.text = result
}

//或者. async .
private fun doOnBack() = lifecycleScope.launch {
   val deferred = async (Dispatchers.IO){
        delay(2000) // 假装努力干活中..
        "变变变, 我是百变小魔女"
    }
    binding.tvTitle.text = deferred.await()
}

• withContext(): 不新建协程, 它只指定 执行当前代码块 所需的线程;
• async: 创建一个协程; 它返回一个Deferred, 而lanuch返回Job对象. 多个async可以支持并发, await()是等待任务执行完毕,并返回结果.
• Dispatchers.IO: 协程调度器. 几种调度器如下所示
  
  

参数	意义
不指定	它从启动了它的 CoroutineScope 中承袭了上下文
Dispatchers.Main	用于Android. 在UI线程中执行
Dispatchers.IO	子线程, 适合执行磁盘或网络 I/O操作
Dispatchers.Default	子线程,适合 执行 cpu 密集型的工作
Dispatchers.Unconfined	管它呢, 不常用, 先不管

由于异步任务需要两段代码块. 子线程代码,及主线程响应; 所以就不封装了; 并且里面其实就一句 withContext(Dispatchers.IO) 或者 val deferred = async (Dispatchers.IO)

3.并行任务:

有时多个任务异步进行, 而我们不清楚哪一个会先完成, 我们需要等待它们的最终结果时.

private suspend fun taskOne(): Int {
    delay(2000)	//模拟任务执行 2秒
    return 1
}

private suspend fun taskTwo(): Int {
    delay(1500) 	//模拟任务执行 1.5秒
    return 2
}

private suspend fun taskExecute(): Int = coroutineScope {
    val result1 = async(Dispatchers.IO) { taskOne() }
    val result2 = async(Dispatchers.IO) { taskTwo() }
    result1.await() + result2.await()
}

//使用
lifecycleScope.launch {
    val sum = taskExecute()
    binding.tvTitle.text = "变变变, 我是百变小魔女$sum"
}

taskOne 执行需要2秒; taskTwo 执行需要1.5秒; 并行, 任务总共耗费约 2秒时间.
suspend: 标志挂起函数, 挂起函数只能在协程中运行.

4.定时任务:

定时任务简单啊, delay()不阻塞线程啊.

lifecycleScope.launch {
    repeat(Int.MAX_VALUE){
        delay(1000L)
        binding.tvTitle.text = "变变变, 我是百变小魔女$it"
    }
}

这个定时任务, 每次执行, 只设置TextView的text.
我们假设我们的业务比较复杂, 每次需要耗费300ms; 如下所示:

lifecycleScope.launch {
    repeat(Int.MAX_VALUE){
        delay(1000L)

        //假设我们的任务比较繁重, 每次需要消耗300ms
        delay(300L)
        binding.tvTitle.text = "变变变, 我是百变小魔女$it"
    }
}

显而易见, 此时至少要 1300ms 才能循环一次. 所以上面写的1000ms只能算是间隔时间. 而任务执行需要时间, 协程挂起,恢复需要时间, 任务进入队列到线程执行也需要时间.

因此:
当定时任务的精确度要求不高, 每次执行的代码任务比较轻便. 耗时较少时, 可以用这种方式.

有的时候, 我们锁屏了, 或者跳到别的页面了, 我们不需要定时一直执行, 即便更新了UI, 我们也看不到啊! 所以,我们希望页面离开时, 定时取消. 页面显示时,重新启动定时即可:
我们就以秒杀倒计时为例;

private var endTime: Long = 0	//秒杀截止时间

//秒杀剩余 5分钟
endTime = System.currentTimeMillis() + 300 * 1000

lifecycleScope.launchWhenResumed {  //onPause 的时候会暂停.
    repeat(Int.MAX_VALUE){
        val now = System.currentTimeMillis()
        binding.tvTitle.text = if(now >= endTime){
            "秒杀结束"
        }else{
            val second = (endTime - now) / 1000 + 1
            "秒杀倒计时($second); it=$it"
        }
        delay(1000L)
    }
}

launchWhenResumed: 当页面 Resumed 时, 启动协程. onPause()时自动停止. 页面重新显示时恢复. 通过观察这里的 it, 可以断定 协程只是被挂起, 而不是销毁重建.
同样的还有: launchWhenCreated; launchWhenStarted 当然这是 lifecycle 的知识了.

有时, 我们需要精确的定时器.

可以用, java.util 包下的 Timer, 如下所示; 也可以用 CountDownTimer

val timer = timer("定时Thread_name", false, 2000, 1000){
    letUsPrintln("定时器, 这是个子线程")
}

当然, 它没有自动暂停恢复的功能; 取消执行时, 别忘了 cancel();

协程+Retrofit 的封装还是放到后面吧..

---

总结

没啥好总结的, 复制粘贴就完事了. 下一篇我们再深入浅出的了解协程 [奸笑]

上一篇: Room-数据持久化存储(进阶)
下一篇: Kotlin Coroutine(协程): 二、初识协程