Kotlin协程使用

什么是Kotlin协程

协程通过将复杂性放入库来简化异步编程。程序的逻辑可以在协程中顺序地表达,而底层库会为我们解决其异步性。该库可以将用户代码的相关部分包装为回调、订阅相关事件、在不同线程(甚至不同机器)上调度执行,而代码则保持如同顺序执行一样简单。

协程就像非常轻量级的线程。线程是由系统调度的,线程切换或线程阻塞的开销都比较大。而协程依赖于线程,但是协程挂起时不需要阻塞线程,几乎是无代价的,协程是由开发者控制的。所以协程也像用户态的线程,非常轻量级,一个线程中可以创建任意个协程。

协程虽然不能脱离线程而运行,但可以在不同的线程之间切换。


协程的优势:
引用库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.1.1"
开启协程
  1. runBlocking
    fun runBlocking() = runBlocking {
        repeat(5) {
            Log.i("minfo", "协程执行$it,当前线程id:${Thread.currentThread().id}")
            delay(1000)
        }
    }

runBlocking启动的协程任务会阻断当前线程,直到该协程执行结束。

2.launch

     fun runCoroutine() {
        Log.i("minfo", "协程开始")
        CoroutineScope(Dispatchers.Default).launch {
            delay(2000)
            Log.i("minfo", "协程内部")
        }
        Log.i("minfo", "协程下面")
    }

launch启动的协程不会阻断当前线程,协程体后面执行的代码仍会继续执行,不会受协程开启的影响。即我们主线程中的耗时操作可以开启协程到子线程中进行处理。

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    val newContext = newCoroutineContext(context)
    val coroutine = if (start.isLazy)
        LazyStandaloneCoroutine(newContext, block) else
        StandaloneCoroutine(newContext, active = true)
    coroutine.start(start, coroutine, block)
    return coroutine
}

launch() 是CoroutineScope的一个扩展函数,CoroutineScope简单来说就是协程的作用范围。CoroutineScope.launch返回类型为Job类型。

取消协程

GlobalScope.launch返回对象job可直接调用cancel取消协程。

 job.cancel()
CoroutineScope

CoroutineScope即协程运行的作用域,主要作用是提供CoroutineContext,协程运行的上下文

public interface CoroutineScope {
    public val coroutineContext: CoroutineContext
}

我们常见的实现有GlobalScope,LifecycleScope,ViewModelScope等

协程下上文

协程是通过Dispatchers调度器来控制线程切换的。
上下文有一个重要的作用就是线程切换,Kotlin协程使用调度器来确定哪些线程用于协程执行,Kotlin提供了调度器给我们使用:


挂起函数

协程体是一个用suspend关键字修饰的一个无参,无返回值的函数类型。被suspend修饰的函数称为挂起函数,与之对应的是关键字resume。 Kotlin 的编译器检测到 suspend 关键字修饰的函数以后,会自动将挂起函数转换成带有 CallBack 的函数,在做完异步事件后,会通过回调通知回去。而调用挂起函数的协程体后面的代码,将不会继续执行,会等待挂起函数执行完成,再继续往下执行。协程本身也是挂起函数。

那我们写一个模拟切到子线程进行耗时操作:

class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        //开启一个协程,切换到主线程
        GlobalScope.launch(Dispatchers.Main) {
            tvContent.text = loadData()
        }
    }

    /**
     * 模拟访问接口获取接口数据
     */
    suspend fun loadData(): String {
        var response = ""
        withContext(Dispatchers.IO) {
            //子线程中模拟耗时操作
            for (i in 0..10000000) {

            }
            response = "response"
        }

        return response
    }

}

在launch开启的协程体里,执行loadData挂起方法,将协程挂起,协程中其后面的代码不会执行,只有等到loadData挂起结束恢复后才会执行。

async/await用于获取返回值处理:
    suspend fun loadData(): String {
        var response = ""
        withContext(Dispatchers.IO) {
            //子线程中模拟耗时操作
            for (i in 0..10000000) {

            }
            response = "response"
        }

        return response
    }

    suspend fun getResult(): String {
        var result = GlobalScope.async(Dispatchers.Main) {
            return@async loadData()
        }
        return result.await()
    }

        GlobalScope.launch(Dispatchers.Main) {
            Log.d("minfo", getResult())
        }
Retrofit结合协程请求网络例子:

Retrofit从2.6.0开始已经支持协程了,如果在网络请求框架中,引入Rxjava仅仅用来与Retrofit结合使用,那就太没有必要了。我们可以用协程来代替Rxjava这部分的功能。

这里是使用玩安卓的接口:https://www.wanandroid.com/banner/json

创建BaseResponse实体类基类:

open class BaseResponse (var errorCode: Int = 0, var errorMsg: String = "", var data: T) : Serializable

在ApiService类中声明一个请求函数 ,声明为挂起函数,类型不需要添加Call。

interface ApiService {

    @GET("banner/json")
    suspend fun getFindData(): BaseResponse>
}

加入数据解析扩展函数:

fun  BaseResponse.dataConvert(): T {
    if (errorCode == 0) {
        return data
    } else {
        throw Exception(errorMsg)
    }
}
object RetrofitServiceManager {
    private val okHttpClient: OkHttpClient
    private val retrofit: Retrofit

    private const val DEFAULT_CONNECT_TIME = 10
    private const val DEFAULT_WRITE_TIME = 30
    private const val DEFAULT_READ_TIME = 30
    private const val REQUEST_PATH = "https://www.wanandroid.com/"

    init {

        okHttpClient = OkHttpClient.Builder()
            .connectTimeout(DEFAULT_CONNECT_TIME.toLong(), TimeUnit.SECONDS)//连接超时时间
            .writeTimeout(DEFAULT_WRITE_TIME.toLong(), TimeUnit.SECONDS)//设置写操作超时时间
            .readTimeout(DEFAULT_READ_TIME.toLong(), TimeUnit.SECONDS)//设置读操作超时时间
            .build()

        retrofit = Retrofit.Builder()
            .client(okHttpClient)//设置使用okhttp网络请求
            .baseUrl(REQUEST_PATH)//设置服务器路径
            .addConverterFactory(GsonConverterFactory.create())//添加转化库,默认是Gson
            .build()

    }

    fun  create(service: Class): T {
        return retrofit.create(service)
    }
}

创建viewModel类,使用viewModelScope开启协程:

class MyViewModel: ViewModel() {
    val items = ObservableArrayList()

    val itemBinding by lazy {
        ItemBinding.of(BR.item, R.layout.item).bindExtra(BR.viewModel, this)
    }

    init {
        getData()
    }

    private fun getData() {
        //viewModelScope是ViewModel的一个扩展函数,也是一个协程
        viewModelScope.launch {
            try {
                var dataBean =  RetrofitServiceManager.create(ApiService::class.java).getFindData().dataConvert()
                items.addAll(dataBean)
            } catch (e: Exception) {
                e.printStackTrace()
                Log.i("TAG", "${e.message}")
            }
        }
    }
}

使用ViewModel:

        var binding: ActivityMainBinding = DataBindingUtil.setContentView(this, R.layout.activity_main)
        binding.lifecycleOwner = this
        binding.viewModel = viewModel
请求结果并显示在列表中:

使用viewModelScrope开启协程,viewModel生命周期与UI组件生命周期一致,父协程结束,那么所有子协程都会结束,就能避免了子协程中内存泄露的情况。

参考

Kotlin 协程 看这一篇就够了
Kotlin协程

协程实现原理——状态机

定义挂起函数

suspend fun requestLoadUser(id: String)
协程的挂起(suspend)和恢复(resume):

反编译之后:

public final Object requestLoadUser(@NotNull String id, @NotNull Continuation $completion) {
      return "";
}

可以看到,多了个Continuation(继续)参数,这是个接口,是在本次函数执行完毕后执行的回调。

public interface Continuation {
    /**
     * 保存上下文(比如变量状态)
     */
    public val context: CoroutineContext
    /**
     * 方法执行结束的回调,参数是个泛型,用来传递方法执行的结果
     */
    public fun resumeWith(result: Result)
}

suspend代码示例:

suspend fun getToken(id: String): String = "token"
suspend fun getInfo(token: String): String = "info"

// 添加了局部变量a,看下suspend怎么保存a这个变量
suspend fun test() {
    val token = getToken("123") // 挂起点1,这里是异步线程
    var a = 10 // 这里是10  //主线程
    val info = getInfo(token) // 挂起点2,需要将前面的数据保存(比如a),在挂起点之后恢复   //异步线程
    println(info)  //主线程
    println(a
}

反编译之后:

public final Object getToken(String id, Continuation completion) {
    return "token";
}

public final Object getInfo(String token, Continuation completion) {
    return "info";
}

// 重点函数(伪代码)
public final Object test(Continuation: continuation) {
    Continuation cont = new ContinuationImpl(continuation) {
        int label; // 保存状态
        Object result; // 保存中间结果,还记得那个Result吗,是个泛型,因为泛型擦除,所以为Object,用到就强转
        int tempA; // 保存上下文a的值,这个是根据具体代码产生的
    };
    switch(cont.label) {
        case 0 : {
            cont.label = 1; //更新label
            
            getToken("123",cont) // 执行对应的操作,注意cont,就是传入的回调
            break;
        }

        case 1 : {
            cont.label = 2; // 更新label
            
            // 这是一个挂起点,我们要保存上下文数据,这里就保存a的值
            int a  = 10;
            cont.tempA = a; // 保存a的值 

            // 获取上一步的结果,因为泛型擦除,需要强转
            String token = (Object)cont.result;
            getInfo(token, cont); // 执行对应的操作
            break;
        }

        case 2 : {
            String info = (Object)cont.result; // 获取上一步的结果
            println(info); // 执行对应的操作

            // 在挂起点之后,恢复a的值
            int a = cont.tempA;
            println(a);

            return;
        }
    }
}

我们可以将每个case理解为一个状态,每个case分支对应的语句,理解为一个Continuation实现。
上述伪代码大致描述了协程的调度流程:

1 调用test函数时,需要传入一个Continuation接口,我们会对它进行二次装饰。
2 装饰就是根据函数具体逻辑,在内部添加额外的上下文数据和状态信息(也就是label)。
3 每个状态对应一个Continuation接口,里面会执行对应的业务逻辑。
4 每个状态都会: 保存上下文信息 -> 获取上一个状态的结果 -> 执行本状态业务逻辑 -> 恢复上下文信息。
5 直到最后一个状态对应的逻辑执行完毕。

总结:

1 Kotlin中,每个suspend方法,都需要一个Continuation接口实现,用来执行下一个状态的操作;并且,每个suspend方法的调用点都会产生一个挂起点。
2 每个挂起点,都会产生一个label,对应于状态机的一个状态,不同的状态之间,通过Continuation来切换。
3 Kotlin协程会在每个挂起点保存当前的上下文数据,并且在挂起点之后进行恢复。这样,每个状态之间就是相互独立的,可以独立调度。
4 协程的切换,只不过是从一种状态切换到另一种状态,因为不同状态是相互独立的,所以在合适的时机,再切换回来也不会对结果造成影响。

参考:https://www.modb.pro/db/211852

https://mp.weixin.qq.com/s/70wBBKwFFLb0X_zrsvNzDA

https://www.bilibili.com/video/BV1KJ41137E9/?spm_id_from=333.337.search-card.all.click&vd_source=40c24e77b23dc2e50de2b7c87c6fed59

https://mp.weixin.qq.com/s?__biz=MzA5MzI3NjE2MA==&mid=2650257918&idx=1&sn=0bde010f58df22508907e213980eb1d6&chksm=88634891bf14c187ac0ad10562c26476a6caf531ded0a772e4bd29bfae23f2accbcebbd04668&scene=27

你可能感兴趣的:(Kotlin协程使用)