聊一聊Kotlin协程“低级“api Pika

最新推荐文章于 2023-10-26 15:09:04 发布

大鱼Ss

最新推荐文章于 2023-10-26 15:09:04 发布

阅读量163

点赞数

分类专栏： Android 技术提升程序员文章标签： kotlin android 开发语言

本文链接：https://blog.csdn.net/m0_59162559/article/details/128185335

版权

Android 同时被 3 个专栏收录

166 篇文章 6 订阅

订阅专栏

程序员

81 篇文章 1 订阅

订阅专栏

技术提升

79 篇文章 0 订阅

订阅专栏

聊一聊kotlin协程“低级”api

Kotlin协程已经出来很久了，相信大家都有不同程度的用上了，由于最近处理的需求有遇到协程相关，因此今天来聊一Kotlin协程的“低级”api，首先低级api并不是它真的很“低级”，而是kotlin协程库中的基础api，我们一般开发用的，其实都是通过低级api进行封装的高级函数，本章会通过低级api的组合，实现一个自定义的async await 函数（下文也会介绍kotlin 高级api的async await），涉及的低级api有startCoroutine ，ContinuationInterceptor 等

startCoroutine

我们知道，一个suspend关键字修饰的函数，只能在协程体中执行，伴随着suspend 关键字，kotlin coroutine common库（平台无关）也提供出来一个api，用于直接通过suspend 修饰的函数直接启动一个协程，它就是startCoroutine

@SinceKotlin("1.3")
@Suppress("UNCHECKED_CAST")
public fun <R, T> (suspend R.() -> T).startCoroutine(
    作为Receiver
    receiver: R,
    当前协程结束时的回调
    completion: Continuation<T>
) {
    createCoroutineUnintercepted(receiver, completion).intercepted().resume(Unit)
}

可以看到，它的Receiver是(suspend R.() -> T)，即是一个suspend修饰的函数，那么这个有什么作用呢？我们知道，在普通函数中无法调起suspend函数（因为普通函数没有隐含的Continuation对象，这里我们不在这章讲，可以参考kotlin协程的资料）

但是普通函数是可以调起一个以suspend函数作为Receiver的函数（本质也是一个普通函数）

其中startCoroutine就是其中一个，本质就是我们直接从外部提供了一个Continuation，同时调用了resume方法，去进入到了协程的世界


startCoroutine实现

createCoroutineUnintercepted(completion).intercepted().resume(Unit)

这个原理我们就不细讲下去原理，之前也有写过相关的文章。通过这种调用，我们其实就可以实现在普通的函数环境，开启一个协程环境（即带有了Continuation），进而调用其他的suspend函数。

ContinuationInterceptor

我们都知道拦截器的概念，那么kotlin协程也有，就是ContinuationInterceptor，它提供以AOP的方式，让外部在resume（协程恢复）前后进行自定义的拦截操作，比如高级api中的Diapatcher就是。当然什么是resume协程恢复呢，可能读者有点懵，我们还是以上图中出现的mySuspendFunc举例子

mySuspendFunc是一个suspned函数
::mySuspendFunc.startCoroutine(object : Continuation<Unit> {
    override val context: CoroutineContext
        get() = EmptyCoroutineContext

    override fun resumeWith(result: Result<Unit>) {

    }

})

它其实等价于

val continuation = ::mySuspendFunc.createCoroutine(object :Continuation<Unit>{
    override val context: CoroutineContext
        get() = EmptyCoroutineContext

    override fun resumeWith(result: Result<Unit>) {
        Log.e("hello","当前协程执行完成的回调")
    }

})
continuation.resume(Unit)

startCoroutine方法就相当于创建了一个Continuation对象，并调用了resume。创建Continuation可通过createCoroutine方法，返回一个Continuation，如果我们不调用resume方法，那么它其实什么也不会执行，只有调用了resume等执行方法之后，才会执行到后续的协程体（这个也是协程内部实现，感兴趣可以看看之前文章）

而我们的拦截器，就相当于在continuation.resume前后，可以添加自己的逻辑。我们可以通过继承ContinuationInterceptor，实现自己的拦截器逻辑，其中需要复写的方法是interceptContinuation方法，用于返回一个自己定义的Continuation对象，而我们可以在这个Continuation的resumeWith方法里面（当调用了resume之后，会执行到resumeWith方法），进行前后打印/其他自定义操作（比如切换线程）

class ClassInterceptor() :ContinuationInterceptor {
    override val key = ContinuationInterceptor
    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =MyContinuation(continuation)

}
class MyContinuation<T>(private val continuation: Continuation<T>):Continuation<T> by continuation{
    override fun resumeWith(result: Result<T>) {
        Log.e("hello","MyContinuation start ${result.getOrThrow()}")
        continuation.resumeWith(result)

        Log.e("hello","MyContinuation end ")
    }
}

其中的key是ContinuationInterceptor，协程内部会在每次协程恢复的时候，通过coroutineContext取出key为ContinuationInterceptor的拦截器，进行拦截调用，当然这也是kotlin协程内部实现，这里简单提一下。

实战

kotlin协程api中的 async await

我们来看一下kotlon Coroutine 的高级api async await用法

CoroutineScope(Dispatchers.Main).launch {
    val block = async(Dispatchers.IO) {
        // 阻塞的事项

    }
    // 处理其他主线程的事务

    // 此时必须需要async的结果时，则可通过await()进行获取
    val result =  block.await()
}

我们可以通过async方法，在其他线程中处理其他阻塞事务，当主线程必须要用async的结果的时候，就可以通过await等待，这里如果结果返回了，则直接获取值，否则就等待async执行完成。这是Coroutine提供给我们的高级api，能够将任务简单分层而不需要过多的回调处理。

通过startCoroutine与ContinuationInterceptor实现自定义的 async await

我们可以参考其他语言的async，或者Dart的异步方法调用，都有类似这种方式进行线程调用

async {
    val result = await {
        suspend 函数
    }
    消费result
}

await在async作用域里面，同时获取到result后再进行消费，async可以直接在普通函数调用，而不需要在协程体内，下面我们来实现一下这个做法。

首先我们想要限定await函数只能在async的作用域才能使用，那么首先我们就要定义出来一个Receiver,我们可以在Receiver里面定义出自己想要暴露的方法

interface AsyncScope {
    fun myFunc(){

    }

}
fun async(
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend AsyncScope.() -> Unit
) {
    // 这个有两个作用 1.充当receiver 2.completion,接收回调
    val completion = AsyncStub(context)
    block.startCoroutine(completion, completion)
}

注意这个类，resumeWith 只会跟startCoroutine的这个协程绑定关系，跟await的协程没有关系
class AsyncStub(override val context: CoroutineContext = EmptyCoroutineContext) :
    Continuation<Unit>, AsyncScope {
    override fun resumeWith(result: Result<Unit>) {

        // 这个是干嘛的 == > 完成的回调
        Log.e("hello","AsyncStub resumeWith ${Thread.currentThread().id} ${result.getOrThrow()}")
    }
}

上面我们定义出来一个async函数，同时定义出来了一个AsyncStub的类，它有两个用处，第一个是为了充当Receiver，用于规范后续的await函数只能在这个Receiver作用域中调用，第二个作用是startCoroutine函数必须要传入一个参数completion，是为了收到当前协程结束的回调resumeWith中可以得到当前协程体结束回调的信息

await方法里面

suspend fun<T> AsyncScope.await(block:() -> T) = suspendCoroutine<T> {
    // 自定义的Receiver函数
    myFunc()

    Thread{
         切换线程执行await中的方法
        it.resumeWith(Result.success(block()))
    }.start()
}

在await中，其实是一个扩展函数，我们可以调用任何在AsyncScope中定义的方法，同时这里我们模拟了一下线程切换的操作（Dispatcher的实现，这里不采用Dispatcher就是想让大家知道其实Dispatcher.IO也是这样实现的），在子线程中调用it.resumeWith(Result.success(block()))，用于返回所需要的信息

通过上面定的方法，我们可以实现

async {
    val result = await {
        suspend 函数
    }
    消费result
}

这种调用方式，但是这里引来了一个问题，因为我们在await函数中实际将操作切换到了子线程，我们想要将消费result的动作切换至主线程怎么办呢？又或者是加入我们希望获取结果前做一些调整怎么办呢？别急，我们这里预留了一个CoroutineContext函数，我们可以在外部传入一个CoroutineContext

public interface ContinuationInterceptor : CoroutineContext.Element
而CoroutineContext.Element又是继承于CoroutineContext
CoroutineContext.Element:CoroutineContext

而我们的拦截器，正是CoroutineContext的子类，我们把上文的ClassInterceptor修改一下


class ClassInterceptor() : ContinuationInterceptor {
    override val key = ContinuationInterceptor
    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =
        MyContinuation(continuation)

}

class MyContinuation<T>(private val continuation: Continuation<T>) :
    Continuation<T> by continuation {
    private val handler = Handler(Looper.getMainLooper())
    override fun resumeWith(result: Result<T>) {
        Log.e("hello", "MyContinuation start ${result.getOrThrow()}")

        handler.post {
            continuation.resumeWith(Result.success(自定义内容))
        }
        Log.e("hello", "MyContinuation end ")
    }
}

同时把async默认参数CoroutineContext实现一下即可

fun async(
    context: CoroutineContext = ClassInterceptor(),
    block: suspend AsyncScope.() -> Unit
) {
    // 这个有两个作用 1.充当receiver 2.completion,接收回调
    val completion = AsyncStub(context)
    block.startCoroutine(completion, completion)
}

此后我们就可以直接通过，完美实现了一个类js协程的调用，同时具备了自动切换线程的能力

async {
    val result = await {
        test()
    }
    Log.e("hello", "result is $result   ${Looper.myLooper() == Looper.getMainLooper()}")
}

结果

  E  start 
  E  MyContinuation start kotlin.Unit
  E  MyContinuation end 
  E  end 
  E  执行阻塞函数 test 1923
  E  MyContinuation start 自定义内容数值
  E  MyContinuation end 
  E  result is 自定义内容的数值   true
  E  AsyncStub resumeWith 2 kotlin.Unit

最后，这里需要注意的是，为什么拦截器回调了两次，因为我们async的时候开启了一个协程，同时await的时候也开启了一个，因此是两个。AsyncStub只回调了一次，是因为AsyncStub被当作complete参数传入了async开启的协程block.startCoroutine，因此只是async中的协程结束才会被回调。

本章代码


class ClassInterceptor() : ContinuationInterceptor {
    override val key = ContinuationInterceptor
    override fun <T> interceptContinuation(continuation: Continuation<T>): Continuation<T> =
        MyContinuation(continuation)

}

class MyContinuation<T>(private val continuation: Continuation<T>) :
    Continuation<T> by continuation {
    private val handler = Handler(Looper.getMainLooper())
    override fun resumeWith(result: Result<T>) {
        Log.e("hello", "MyContinuation start ${result.getOrThrow()}")

        handler.post {
            continuation.resumeWith(Result.success(6 as T))
        }
        Log.e("hello", "MyContinuation end ")
    }
}

interface AsyncScope {
    fun myFunc(){

    }

}
fun async(
    context: CoroutineContext = ClassInterceptor(),
    block: suspend AsyncScope.() -> Unit
) {
    // 这个有两个作用 1.充当receiver 2.completion,接收回调
    val completion = AsyncStub(context)
    block.startCoroutine(completion, completion)
}

class AsyncStub(override val context: CoroutineContext = EmptyCoroutineContext) :
    Continuation<Unit>, AsyncScope {
    override fun resumeWith(result: Result<Unit>) {

        // 这个是干嘛的 == > 完成的回调
        Log.e("hello","AsyncStub resumeWith ${Thread.currentThread().id} ${result.getOrThrow()}")
    }
}

suspend fun<T> AsyncScope.await(block:() -> T) = suspendCoroutine<T> {
    myFunc()

    Thread{
        it.resumeWith(Result.success(block()))
    }.start()
}

模拟阻塞
fun test(): Int {
    Thread.sleep(5000)
    Log.e("hello", "执行阻塞函数 test ${Thread.currentThread().id}")
    return 5
}

async {
    val result = await {
        test()
    }
    Log.e("hello", "result is $result   ${Looper.myLooper() == Looper.getMainLooper()}")
}

最后

我们通过协程的低级api，实现了一个与官方库不同版本的async await，同时也希望通过对低级api的设计，也能对Coroutine官方库的高级api的实现有一定的了解。

作者：Pika
链接：https://juejin.cn/post/7172813333148958728

文末福利

如果想要成为架构师或想突破20~30K薪资范畴，那就不要局限在编码，业务，要会选型、扩展，提升编程思维。此外，良好的职业规划也很重要，学习的习惯很重要，但是最重要的还是要能持之以恒，任何不能坚持落实的计划都是空谈。

如果你没有方向，这里给大家分享一套由阿里高级架构师编写的《Android八大模块进阶笔记》，帮大家将杂乱、零散、碎片化的知识进行体系化的整理，让大家系统而高效地掌握Android开发的各个知识点。

在这里插入图片描述
相对于我们平时看的碎片化内容，这份笔记的知识点更系统化，更容易理解和记忆，是严格按照知识体系编排的。

一、架构师筑基必备技能

1、深入理解Java泛型
2、注解深入浅出
3、并发编程
4、数据传输与序列化
5、Java虚拟机原理
6、高效IO
……

在这里插入图片描述

二、Android百大框架源码解析

1.Retrofit 2.0源码解析
2.Okhttp3源码解析
3.ButterKnife源码解析
4.MPAndroidChart 源码解析
5.Glide源码解析
6.Leakcanary 源码解析
7.Universal-lmage-Loader源码解析
8.EventBus 3.0源码解析
9.zxing源码分析
10.Picasso源码解析
11.LottieAndroid使用详解及源码解析
12.Fresco 源码分析——图片加载流程

三、Android性能优化实战解析

腾讯Bugly:对字符串匹配算法的一点理解
爱奇艺：安卓APP崩溃捕获方案——xCrash
字节跳动：深入理解Gradle框架之一：Plugin, Extension, buildSrc
百度APP技术：Android H5首屏优化实践
支付宝客户端架构解析：Android 客户端启动速度优化之「垃圾回收」
携程：从智行 Android 项目看组件化架构实践
网易新闻构建优化：如何让你的构建速度“势如闪电”？
…

四、高级kotlin强化实战

1、Kotlin入门教程
2、Kotlin 实战避坑指南
3、项目实战《Kotlin Jetpack 实战》

从一个膜拜大神的 Demo 开始
Kotlin 写 Gradle 脚本是一种什么体验？
Kotlin 编程的三重境界
Kotlin 高阶函数
Kotlin 泛型
Kotlin 扩展
Kotlin 委托
协程“不为人知”的调试技巧
图解协程：suspend

五、Android高级UI开源框架进阶解密

1.SmartRefreshLayout的使用
2.Android之PullToRefresh控件源码解析
3.Android-PullToRefresh下拉刷新库基本用法
4.LoadSir-高效易用的加载反馈页管理框架
5.Android通用LoadingView加载框架详解
6.MPAndroidChart实现LineChart（折线图）
7.hellocharts-android使用指南
8.SmartTable使用指南
9.开源项目android-uitableview介绍
10.ExcelPanel 使用指南
11.Android开源项目SlidingMenu深切解析
12.MaterialDrawer使用指南

六、NDK模块开发

1、NDK 模块开发
2、JNI 模块
3、Native 开发工具
4、Linux 编程
5、底层图片处理
6、音视频开发
7、机器学习

在这里插入图片描述

七、Flutter技术进阶

1、Flutter跨平台开发概述
2、Windows中Flutter开发环境搭建
3、编写你的第一个Flutter APP
4、Flutter开发环境搭建和调试
5、Dart语法篇之基础语法(一)
6、Dart语法篇之集合的使用与源码解析(二)
7、Dart语法篇之集合操作符函数与源码分析(三)
…

八、微信小程序开发

1、小程序概述及入门
2、小程序UI开发
3、API操作
4、购物商场项目实战……

全套视频资料：

一、面试合集
在这里插入图片描述
二、源码解析合集

在这里插入图片描述
三、开源框架合集

在这里插入图片描述
欢迎大家一键三连支持，若需要文中资料，直接点击文末CSDN官方认证微信卡片免费领取↓↓↓

大鱼Ss

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
聊一聊Kotlin协程“低级“api Pika

Kotlin协程已经出来很久了，相信大家都有不同程度的用上了，由于最近处理的需求有遇到协程相关，因此今天来聊一Kotlin协程的“低级”api，首先低级api并不是它真的很“低级”，而是kotlin协程库中的基础api，我们一般开发用的，其实都是通过低级api进行封装的高级函数，本章会通过低级api的组合，实现一个自定义的async await 函数（下文也会介绍kotlin 高级api的async await），涉及的低级api有startCoroutine ，ContinuationIntercepto
复制链接

扫一扫

专栏目录