在后台线程执行硬任务，在主线程返回结果

Question

我花了一些时间寻找一个开发人员友好的解决方案（不向项目添加依赖项）如何在后台线程中执行一些硬任务，并在任务完成后将结果返回到主线程。我找到了允许这样做的“AsyncTask”。但是要使用它，您需要为需要在后台运行的每个任务编写样板代码。我是 iOS 开发者，决定尝试 Android 相关的开发。所以在 Swift 中你可以简单地使用下面的代码来完成这个任务：

DispatchQueue.global().async(execute: {
      //Do some hard task in background
   DispatchQueue.main.async(execute: {
      //Return to main
   })
})

这看起来很简单。但是在 Kotlin 中我没有找到这么简单的解决方案，于是决定创建它。

这是我做的：

我创建了通用类

import android.os.AsyncTask

class BaseAsyncTask<M>: AsyncTask<()->M, Int, M>() {

    var completion: ((M)->Unit)? = null

    override fun doInBackground(vararg params: (() -> M)?): M? {
        for (p in params) {
            return p?.invoke()
        }
        return  null
    }

    override fun onPostExecute(result: M) {
        super.onPostExecute(result)

        completion?.invoke(result)
    }
}

和经理

class AsyncManager {

    companion object {

        fun <M>execute(inBackground: ()->M, inMain: (M)->Unit): BaseAsyncTask<M> {
            val task = BaseAsyncTask<M>()
            task.completion = inMain
            task.execute(inBackground)

            return task
        }

        fun <M>execute(inBackground: ()->M): BaseAsyncTask<M> {
            val task = BaseAsyncTask<M>()
            task.execute(inBackground)

            return task
        }
    }

}

现在我这样使用它：

AsyncManager.execute({
   //Do some hard task in background
}, {
  //Return to main
})

看起来对开发者友好。

Log.e("MAIN", "MAIN THREAD SHOULD NOT BE BLOCKED")

AsyncManager.execute({
    Log.e("TASK", "Started background task")
    val retval = "The value from background"
    Thread.sleep(5000)
    Log.e("TASK", "Finished background task with result: " + retval)
    retval
}, {
    Log.e("TASK", "Started task in Main thread with result from Background: " + it)
})

Log.e("MAIN", "MAIN THREAD SHOULD NOT BE BLOCKED - 1")

还有日志：

2019-03-27 17:11:00.719 17082-1​​7082/com.test.testapp E/MAIN: MAIN 线程不应该被阻塞

2019-03-27 17:11:00.722 17082-1​​7082/com.test.testapp E/MAIN: MAIN 线程不应该被阻塞 - 1

2019-03-27 17:11:00.722 17082-1​​7124/com.test.testapp E/TASK: 开始 后台任务

2019-03-27 17:11:05.737 17082-1​​7124/com.test.testapp E/TASK: 完成 具有结果的后台任务：来自后台的值

2019-03-27 17:11:05.738 17082-1​​7082/com.test.testapp E/TASK: 开始 主线程中的任务，结果来自背景：值来自 背景

所以问题是专业的 Android 开发人员如何看待这个解决方案。如果我会使用它，我会遇到什么问题。也许有一些理由不使用这个解决方案。

Answer 1

如果您使用 Kotlin，正确的方法是通过 Coroutines，这样您就可以编写如下代码：

// Launch a coroutine that by default goes to the main thread
GlobalScope.launch(Dispatchers.Main) {
    // Switch to a background (IO) thread
    val retval = withContext(Dispatchers.IO) {
        Log.e("TASK", "Started background task")
        val retval = "The value from background"
        Thread.sleep(5000)
        Log.e("TASK", "Finished background task with result: " + retval)
        retval
    }
    // Now you're back the main thread
    Log.e("TASK", "Started task in Main thread with result from Background: " + retval)
}

请注意，Kotlin 协程在 structured concurrency 下运行，因此您通常希望避免使用 GlobalScope，而是将您的协程范围绑定到您的 Activity / Fragment 生命周期。这通常需要您自己立即完成。

Answer 2

ianhanniballake's answer 是正确的，但可能有点不完整，所以我想我会提供一个完整的通用示例。

build.gradle(:app):

dependencies { // this line is probably already present
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.3"
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.3"
}

全局 CoroutineScope 不绑定到任何作业。
使用 GlobalScope 启动整体运行的顶级协程 应用程序生命周期，并且不会提前取消。应用 代码通常应该使用应用程序定义的 CoroutineScope。
使用 强烈建议不要在 GlobalScope 实例上进行异步或启动。 _取自here

所以你想使用任何生命周期为CoroutineScope 的类，这样当它死亡时，它会将运行的后台任务带入坟墓。通常，人们建议为此使用活动。但是，有一个case to be made，您不希望任何外部类将您的活动用作他们的CoroutineScope，因此您可以使用受保护的字段：

protected val scope = CoroutineScope(Job() + Dispatchers.Main)

在撰写本文时，我不知道为什么我们必须在这里创建一个Job()。我所知道的是 + 运算符被重载以将这两个上下文合并为一个。对于Dispatcher部分，你可以选择一个合理的。选项包括

• Dispatchers.Main 用于 UI 线程
• Dispatchers.Default 用于后台线程池
• Dispatchers.IO 用于阻塞 I/O 密集型操作
• Dispatchers.Unconfined 当您真正知道自己在做什么时。 This article 不鼓励“正常”使用它。

现在所有这些都解决了，代码变得非常简单：

import kotlin.coroutines.*
// ...
myButton.setOnClickListener() { v: View? ->
                myButton.setColorToYellow() // some UI thread work
                scope.launch(Dispatchers.Default) {
                    val result = longComputation() // some background work

                    withContext(Dispatchers.Main) {
                        // some UI thread work for when the background work is done
                        root.findViewById<TextView>(R.id.text_home).text = "Result: $result"
                    }
                }
                myButton.setColorToRed() // more UI thread work. this is done instantly
       }

当然，这可以在任何地方完成 - 我只是使用一个按钮和一个 onClickListener 来举例说明一个可能的用例。