Kotlin协程是个什么东西?

3,525 阅读7分钟

协程是什么

根据维基百科的定义,协程(Coroutine)是计算机程序的一类组件,推广了协作式多任务的子程序,允许执行被挂起与被恢复。

协程(Coroutine)并不是一个新词,马尔文·康威于1958年发明了术语“coroutine”,并将它用于汇编程序。而在其他语言,如Go、Python也都有协程的概念,所以它也不是Kotlin独有的。

在不同的语言层面上,协程的实现方式是不太一样的,本文介绍的Kotlin协程在本质上,它是一种轻量级的线程

Kotlin协程是运行在线程中的,这里的线程可以是单线程,也可以是多线程。在单线程使用协程,比不使用协程的耗时并不会少。

上面介绍的都是协程的一些概念,以及Kotlin协程的特点。那究竟为什么会有Kotlin协程?它究竟比线程好在哪里?我们继续往下看。

Kotlin协程初认识

在Kotlin中,协程就是线程的封装,它提供了一套标准的API来帮助我们写并发任务。回想一下,在Java和Android中,我们是怎么写并发任务的?

Java实现多任务并发

在Java中,我们可以使用线程或者线程池来实现多任务并发:

//线程
new Thread(new Runnable() {
    @Override
    public void run() {
        //耗时的工作
    }
}).start();

//线程池
ExecutorService executor = Executors.newFixedThreadPool(3);
executor.execute(new Runnable() {
    @Override
    public void run() {
        //耗时的工作
    }
});

Android实现多任务并发

在Android中,除了可以通过Java的方式,创建线程、使用线程池实现多任务并发之外,还可以AsyncTask等方式来实现多个耗时任务的并发执行:

//AsyncTask
public abstract class AsyncTask<Params, Progress, Result> {
  //线程池中执行,执行耗时任务
  protected abstract Result doInBackground(Params... params);
  //UI线程中执行,后台任务进度有变化则执行该方法
  protected void onProgressUpdate(Progress... values) {}
  //UI线程执行,耗时任务执行完成后,该方法会被调用,result是任务的返回值
  protected void onPostExecute(Result result) {}
}

无论是Java还是Android提供的组件,都可以实现多任务并发的执行,但是上面的组件都或多或少存在着问题:

  • 耗时任务执行结束后,子线程要将结果传递回主线程,两者之间的通信不太方便。
  • AsyncTask处理的回调方法比较多,当有多个任务时可能会出现回调嵌套。

协程实现多任务并发

继续以AsyncTask举个🌰:

AsyncTask<String, Integer, String> task = new AsyncTask<String, Integer, String>() {
    @Override
    protected String doInBackground(String... strings) {
        String userId = getUserId(); //获取userId
        return userId;
    }

    @Override
    protected void onPostExecute(final String userId) {
        AsyncTask<String, Integer, String> task1 = new AsyncTask<String, Integer, String>() {
            @Override
            protected String doInBackground(String... strings) {
                String name = getUserName(userId); //获取userName,需要用到userId
                return name;
            }

            @Override
            protected void onPostExecute(String name) {
                textView.setText(name); //设置到TextView控件中
            }
        };
        task1.execute(); //假设task1是一个耗时任务,去获取userName
    }
};
task.execute(); //假设task是一个耗时任务,去获取userId

如果是使用协程,上面的例子可以简化为:

GlobalScope.launch(Dispatchers.Main) {
    val userId = getUserId() //耗时任务,这里会切换到子线程
    val userName = getUserName(userId) //耗时任务,这里会切换到子线程
    textView.text = userName //设置到TextView控件中,切换到主线程
}

suspend fun getUserId(): String = withContext(Dispatchers.IO) {
    //耗时操作,返回userId
}

suspend fun getUserName(userId: String): String = withContext(Dispatchers.IO) {
    //耗时操作,返回userName
}

上面launch函数的{}的逻辑,就是一个协程。

相比于AsyncTask的写法,使用kotlin协程有以下好处:

  • 协程将耗时任务和UI更新放在了上下三行处理,消除了AsyncTask的回调嵌套,使用起来更加方便、简洁。
  • 协程通过挂起与恢复,将耗时任务的结果直接返回给调用方,使得主线程能直接使用子线程的结果,UI更新更加方便。

Kotlin协程的接入与使用

怎么接入

在模块的build.gradle中加入以下依赖:

dependencies {
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$1.3.9"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9"
}

怎么使用

Kotlin提供了三种方式来创建协程,如下所示:

//方式一
runBlocking { //runBlocking是一个顶级函数
   ...
}

//方式二
GlobalScope.launch { //GlobalScope是一个单例对象,直接使用launch开启协程
   ...
}

//方式三
val coroutineScope = CoroutineScope(context) //使用CoroutineContext创建CoroutineScope对象,通过launch开启协程
coroutineScope.launch {
   ...
}
  • 方式一:它是线程阻塞的,它通常被用在单元测试和main函数中,平时的开发中我们一般不会用到它。
  • 方式二:与方式一相比,它不会阻塞线程,但是它的生命周期和应用是一致的,而且无法做到取消(后面会讲到),所以也不推荐使用。
  • 方式三:通过CoroutineContext来创建一个CoroutineScope对象,通过CoroutineScope.launchCoroutineScope.async可以开启协程,通过CoroutineContext也可以控制协程的生命周期。在开发过程中,一般推荐使用这种方式开启协程。

CoroutineContext

上面说到推荐使用CoroutineScope.launch开启协程,而不管是GlobalScope.launch还是CoroutineScope.launchlaunch方法的第一个参数就是CoroutineContext,源码如下:

public fun CoroutineScope.launch(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> Unit
): Job {
    ...
}

这里的context,即CoroutineContext,它的其中一个作用是起到线程切换的功能,即协程体将运行在CoroutineContext表征的指定的线程中。

Kotlin协程官方定义了几个值,可供我们在开发过程中使用,它们分别是:

  • Dispatchers.Main

协程体将运行在主线程,用于UI的更新等需要在主线程执行的场景,这个大家应该都清楚。

  • Dispatchers.IO

协程体将运行在IO线程,用于IO密集型操作,如网络请求、文件操作等场景。

  • Dispatchers.Default

协程体将运行在默认的线程,context没有指定或指定为Dispatchers.Default,都属于这种情况。用于CPU密集型,如涉及到大量计算等场景。要特别注意的是,这里的默认线程,其实和上面的IO线程共享同一个线程池。

  • Dispatchers.Unconfined

不受限的调度器,在开发中不应该使用它,暂不研究。

看一下下面这个例子:

GlobalScope.launch(Dispatchers.Main) {
    println("Main Dispatcher,  currentThread=${Thread.currentThread().name}")
}
GlobalScope.launch {
    println("Default Dispatcher1, currentThread=${Thread.currentThread().name}")
}
GlobalScope.launch(Dispatchers.IO) {
    println("IO Dispatcher,  currentThread=${Thread.currentThread().name}")
}
GlobalScope.launch(Dispatchers.Default) {
    println("Default Dispatcher2, currentThread=${Thread.currentThread().name}")
}

程序运行结果如下:

image.png

可以看到,Dispatchers.Main调度器的协程运行在主线程,而无调度器、Dispatchers.IODispatchers.Default调度器的协程运行在同一个线程池。

launch与async

上面提到可以使用launch来创建一个协程,但是除了使用launch之外,Kotlin还提供了async来帮助我们创建协程。两者的区别是:

  • launch:创建一个协程,返回一个Job,但是并不携带协程执行后的结果。
  • async:创建一个协程,返回一个Deferred(也是一个Job),并携带协程执行后的结果。

async返回的Deferred是一个轻量级的非阻塞future,它代表的是一个将会在稍后提供结果的promise,所以它需要使用await方法来得到最终结果。拿Kotlin官方的一个例子对async进行说明:

val one = async { doSomethingUsefulOne() }
val two = async { doSomethingUsefulTwo() }
println("The answer is ${one.await() + two.await()}")

suspend fun doSomethingUsefulOne(): Int {
    delay(1000L) // 假设我们在这里做了些有用的事
    return 13
}

suspend fun doSomethingUsefulTwo(): Int {
    delay(1000L) // 假设我们在这里也做了些有用的事
    return 29
}

执行上述代码,得到的结果是:

The answer is 42

Kotlin协程的使用场景

线程切换

在介绍《CoroutineContext》一节时,举的例子中的协程还是运行在单一线程中。在实际开发过程中,常见的场景就是线程的切换与恢复,这需要用到withContext方法了。

withContext

我们继续以《与线程的对比》这一节的例子来说明:

GlobalScope.launch(Dispatchers.Main) {
    val userId = withContext(Dispatchers.IO) {
        getUserId() //耗时任务,这里会切换到子线程
    }
    textView.text = userId //设置到TextView控件中,切换到主线程
}

上面是一个典型的网络请求场景:一开始运行在主线程,然后需要到后台获取userId的值(这里会执行getUserId方法),获取结束,结果返回后,会切换回主线程,最后更新UI控件。

在获取userId的时候,调用了getUserId方法,这里用到了withContext方法,将线程从main切换到了IO线程,当耗时任务执行结束后(即上面的getUserId方法执行完毕),withContext的另外一个作用是恢复到切换子线程前的所在线程,对应上面的例子是main线程,所以我们才能做更新UI控件的操作。

我们也可以将withContext的逻辑单独放到一个方法去管理,如下所示:

GlobalScope.launch(Dispatchers.Main) {
    val userId = getUserIdAsync()
    textView.text = userId //设置到TextView控件中,切换到主线程
}

fun getUserIdAsync() = withContext(Dispatchers.IO) {
    getUserId() //耗时任务,这里会切换到子线程
}

这样看上去就像在使用同步调用的方式执行异步逻辑,但是如果按照上面的方式来写,IDE会报错的,提示信息是: Suspend function'withContext' should be called only from a coroutine or another suspend funcion

意思是withContext是一个suspend方法,它需要在协程或另外一个suspend方法中被调用。

suspend

suspend是Kotlin协程的一个关键字,它表示 “挂起” 的意思。所以上面的报错,只要加上suspend关键字就能解决,即:

GlobalScope.launch(Dispatchers.Main) {
    val userId = getUserIdAsync()
    textView.text = userId //设置到TextView控件中,切换到主线程
}

suspend fun getUserIdAsync() = withContext(Dispatchers.IO) {
    getUserId() //耗时任务,这里会切换到子线程
}

当代码执行到suspend方法时,当前协程就会被挂起,这里所说的挂起是非阻塞的,也就是说它不会阻塞当前所在的线程。这就是所谓的“非阻塞式挂起”。

非阻塞式挂起与协程的执行步骤

非阻塞式挂起的一个前提是:涉及的必须是多线程的操作。因为阻塞的概念是针对单线程而言的。当我们切换了线程,那肯定是非阻塞的,因为耗时的操作跑到别的线程了,原来的线程就自由了,该干嘛干嘛呗~

如果在主线程中启动多个协程,那么协程的执行顺序是怎样的呢?是按照代码顺序执行么?还是有别的执行顺序?如下代码所示,假设test方法在主线程中执行,那么这段代码应该输出什么呢?

//假设test方法运行在主线程
fun test() {
    println("start test fun, thread=${Thread.currentThread().name}")
    //协程A
    GlobalScope.launch(Dispatchers.Main) {
        println("start coroutine1, thread=${Thread.currentThread().name}")
        val userId = getUserIdAsync()
        println("end coroutine1, thread=${Thread.currentThread().name}")
    }
    //协程B
    GlobalScope.launch(Dispatchers.Main) {
        println("start coroutine2, thread=${Thread.currentThread().name}")
        delay(100)
        println("end coroutine2, thread=${Thread.currentThread().name}")
    }
    println("end test fun, thread=${Thread.currentThread().name}")
}

suspend fun getUserIdAsync() = withContext(Dispatchers.IO) {
    println("getUserIdAsync, thread=${Thread.currentThread().name}")
    delay(1000)
    return@withContext "userId from async"
}

在Android中运行上述代码,执行结果是:

image.png

通过打印的日志可以看到,虽然协程的代码顺序在println("end test fun...")之前,但是在执行顺序上,协程的启动仍然在println("end test fun...")之后,结合非阻塞式挂起,下图展示了协程的执行顺序流程:

image.png

参考文档

1、Kotlin 的协程用力瞥一眼 - 学不会协程?很可能因为你看过的教程都是错的

2、协程入门指南

3、最全面的kotlin协程