一篇文章揭开Kotlin协程的神秘面纱

前言

Kotlin协程提供了一种新的异步执行方式，但直接查看库函数可能会有点混乱，本文中尝试揭开协程的神秘面纱。

理论

它是什么

这是别人翻译: 协程把异步编程放入库中来简化这类操作。程序逻辑在协程中顺序表述，而底层的库会将其转换为异步操作。库会将相关的用户代码打包成回调，订阅相关事件，调度其执行到不同的线程（甚至不同的机器），而代码依然想顺序执行那么简单。

我的理解：子任务程协作运行，优雅的处理异步问题解决方案。

它能干什么?

我在做安卓开发，它能替换掉Handler,AsyncTask 甚至是Rxjava来优雅的解决异步问题。

下面让我们从基础开始吧，假设有一个名为launch可以用来启动协程

private fun myHeavyFunction() {
 Log.e("Thread Running ", Thread.currentThread().name)
}
val job = launch { myHeavyFunction() }

上面的代码是使用launch一种非常简单的方法，返回Job一个异步执行函数，Job代表一个协程coroutine作业，可以取消或查询它的状态。

override fun onStop() {
 if (job.isActive) {
  job.cancel()
 }
}

现在，如果查看我们的日志，检查我们的函数实际运行的是哪个线程？我们就会得到类似的结果

E / Thread运行：ForkJoinPool.commonPool-worker-2

我们的代码是在一个线程中运行的，让我们稍微了解一下launch本身:

public fun launch(
 context:CoroutineContext =DefaultDispatcher,
 start:CoroutineStart CoroutineStart.DEFAULT,
 parent:Job?=null,
 onComp1etion:CompletionHand1er? =null,
 block:suspend CoroutineScope.()->Unit
):Job{ 

再看看DefaultDispatcher的值是什么？

@Suppress("PropertyName ")
public actual val DefaultDispatcher: CoroutineDispatcher = CommonPool

object CommonPool:CoroutineDispatcher()

launch是将CoroutineContext作为第一个参数，这个参数值默认为代表一个CommonPool线程池类的DefaultDispatcher，这个线程池类根据当前CPU处理器总数创建一个带有Executors的CoroutineContext。完整代码在这里。

launch是一种协程构建器，可以接受一个协程分配器CoroutineDispatcher，分配器实际上负责在单独的线程中运行代码。

我们可以轻松创建自己的分配器：

val singleThreadDispatcher = newSingleThreadContext("singleThreadDispatcher")

newSingleThreadContext 由Kotlin协同程序库本身提供，用于创建仅在单个线程上运行的上下文。我们可以在此基础上创建自己的函数：

fun <T> singleThreadAsync(block: () -> T): Job = launch(singleThreadDispatcher) { block.invoke() }

job = singleThreadAsync { myHeavyFunction() }

下面是运行后的日志

E / Thread运行：singleThreadDispatcher

所以我们用我们自己的线程方案创建了我们自己的简单协程:)

让我们看看我们可以通过Dispatchers做更多事情：

object MyDispatcher : CoroutineDispatcher() {
 override fun dispatch(context: CoroutineContext, block: Runnable) {
  thread {
   block.run()
  }
 }
}

object RxDispatcher : CoroutineDispatcher() {
 override fun dispatch(context: CoroutineContext, block: Runnable) {
  Observable.fromCallable { block.run() }
    .subscribeOn(Schedulers.io())
    .subscribe {}

 }
}

object UIDispatcher : CoroutineDispatcher() {
 override fun dispatch(context: CoroutineContext, block: Runnable) {
  Handler(Looper.getMainLooper()).post {
   block.run()
  }
 }
}

在这里，我们创建了三个不同的分配器程序并重载了dispatch方法， 我们在每个dispatch方法中以不同的方式执行Runnable块，也就是一个简单的线程，这个异步线程是使用RxJava实现，而Android主线程是使用Handler完成。

如果我们用这些分配器程序执行我们的函数，我们会得到这些日志

E / Thread Running：Thread-582
E / Thread Running：RxCachedThreadScheduler-1
E / Thread Running：main

这真的显示了协同程序的强大功能，因为Coroutines只是语言语法，它们与运行它们的平台无关。不同线程的职责分配只需开发人员使用一组函数就能实现，他可以在Rx线程或主线程上执行他喜欢的协同程序。

协同程序就像空的冰淇淋甜筒，你可以选择你想要冰淇淋的填入。

无线程Thread-less异步

编写异步代码传统上被认为是一种线程工作，其实并不总是如此，让我们看看如何使用Coroutines解决这个问题

让我们看看一系列函数执行

mySmallFunction1()
myHeavyFunction() // Takes 3 seconds to execute
mySmallFunction2()
//Order运行顺序
E/mySmallFunction1 running on: main
E/myHeavyFunction running on: main
E/mySmallFunction2 running on: main

现在因为myHeavyFunction()函数需要很长时间才能执行，所以我们可能想要异步执行它。

mySmallFunction1()
thread { myHeavyFunction() } //Execution in a separate thread.
mySmallFunction2()
//Order顺序
E/mySmallFunction1 running on: main
E/mySmallFunction2 running on: main
E/myHeavyFunction running on: Thread-697

这里我们将myHeavyFunction()迁移到一个单独的线程并异步执行它，但是如果我们这样做：

mySmallFunction1()
launch(UI) { myHeavyFunction() }
mySmallFunction2()
//Order
E/mySmallFunction1 running on: main
E/mySmallFunction2 running on: main
E/myHeavyFunction running on: main

这里我们在主线程上运行的Coroutine上下文（UI：由coroutine-android库提供）中执行重量函数，执行仍然是异步的，因为Coroutines是通过暂停这部分函数处理，但函数执行仍然发生在主线程上，而不创建额外的线程。

实战协程

在大多数情况下，我们需要来自一个异步执行的回调，这样我们就可以通过回调函数来更新UI等，这里就可以使用Deferred语法：

Deferred本身继承扩展了Job，但增加一个额外的功能，它可以在函数完成执行后返回未来的值。

让我们看看我们在这里做了什么:

fun <T> asyncExecutor(block: () -> T, response: (T) -> Unit): Job {
 return launch(UI) {
  val deferred = async(singleThreadDispatcher) { block.invoke() }
  response.invoke(deferred.await())
 }
}

让我们分析一下：

1. launch（UI）使用Android的UI所在的线程上下文创建一个协同Job。

2. 我们通过async异步创建了另一个协同程序，其中包含我们需要调用的函数，唯一的区别是：这个协程返回一个Deferred值，async是协程库的一部分。

3. 我们调用await（）函数来捕获Deferred的未来值。这是在UI所在线程上下文中捕获的。

总而言之，我们创建了一个异步执行程序，我们可以在其中传递函数并让它们异步执行，然后将值返回给UI线程。

现在我们在哪里可以使用它 ? 数据库查询

// Insert into DB without callback
singleThreadAsync { movieDataBase.movieDao().insert(movieObject) }

// Get List of movies from DB and filter it
asyncExecutor({ movieDataBase.movieDao().getAll() }, { movieList ->
 movieList
   .filter { it.isFavorite }
   .map { it.originalLanguage = "English" }
 //Dispatch to UI
})

我们将插入到DB的请求变成了一个发射就可以忘记不用等待结果的异步请求，这是使用singleThreadAsync实现的 。

当我们从DB检索数据时，我们可以使用我们的asyncExecutor来检索对象列表，然后使用Collection Framework中的运算符发挥所有kotlin优点啦！

总结

以上就是这篇文章的全部内容了，希望本文的内容对大家的学习或者工作具有一定的参考学习价值，如果有疑问大家可以留言交流，谢谢大家对我们的支持。