Android 异步任务的三种方式：AsyncTask，Handler+Thread，RxJava

一、AsyncTask使用示例

1.1.新建MyTask

/**
 * AsyncTask中的三个参数分别表示：后台任务需要的参数类型，更新进度时的参数类型，结果参数类型
 */
class MyTask : AsyncTask<Int, Int, Int>() {

    /**
     * 任务执行前调用
     */
    override fun onPreExecute() {
        super.onPreExecute()
        Log.d("~~~", "开始计算...")
    }

    /**
     * 后台执行任务
     */
    override fun doInBackground(vararg params: Int?): Int {
        return params.reduce { acc, i ->
            val result = acc!! + i!!
            // 更新进度
            publishProgress(result)
            result
        }!!
    }

    /**
     * 进度更新
     */
    override fun onProgressUpdate(vararg values: Int?) {
        super.onProgressUpdate(*values)
        Log.d("~~~", "当前结果是:${values[0]}")
    }

    /**
     * 任务执行完成后调用
     */
    override fun onPostExecute(result: Int?) {
        super.onPostExecute(result)
        Log.d("~~~", "计算完成，结果是$result")
    }
}

1.2.使用execute启动Task

// 传入参数，开启后台任务
task.execute(1, 1, 1)

运行程序，Log显示如下：

~~~: 开始计算...
~~~: 当前结果是:2
~~~: 当前结果是:3
~~~: 计算完成，结果是3

二、Handler+Thread使用示例

2.1.新建MyThread，使用start启动Thread

class MyThread : Thread() {

    override fun run() {
        super.run()
        // TODO 执行耗时任务
        // 使用Handler切换到主线程
        MainActivity.handler.sendEmptyMessage(2333)
    }
}

MainActivity中：

class MainActivity : AppCompatActivity() {
    companion object {
        val handler = Handler {
            Log.d("~~~", "got it:${it.what}")
            true
        }
    }

    ...
}

调用start启动Thread：

MyThread().start()

运行程序，Log显示如下：

~~~: got it:2333

2.2.子线程中使用Handler

子线程中使用Handler需要手动调用Looper的prepare和loop方法：

class MyThread : Thread() {

    override fun run() {
        super.run()
        Looper.prepare()
        val handler = object : Handler() {
            override fun handleMessage(msg: Message?) {
                super.handleMessage(msg)
                Log.d("~~~", "Thread got it:${msg?.what}")
            }
        }
        handler.sendEmptyMessage(1234)
        Looper.loop()
    }
}

调用start启动Thread：

MyThread().start()

运行程序，Log显示如下：

~~~: Thread got it:1234

2.3.HandlerThread使用示例

HandlerThread是一个自带Looper的Thread，HandlerThread可以实现在单线程中处理任务，使用Handler来控制此线程中的处理逻辑。使用方式如下：

class MainActivity : AppCompatActivity() {
    val handlerThread = HandlerThread("myHandlerThread")

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        startHandlerThread()
    }

    private fun startHandlerThread() {
        if(!handlerThread.isAlive){
            handlerThread.start()
        }
        val handler = object : Handler(handlerThread.looper) {
            override fun handleMessage(msg: Message?) {
                super.handleMessage(msg)
                Log.d("~~~", "Handler Thread got it:${msg?.what}")
            }
        }
        handler.sendEmptyMessage(123)
    }

    override fun onDestroy() {
        super.onDestroy()
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            handlerThread.quitSafely()
        } else {
            handlerThread.quit()
        }
    }
}

运行程序，Log显示如下：

~~~: Handler Thread got it:123

查看HandlerThread的源码可以发现，它的实现原理和2.2中的原理一样，也是在内部调用了Looper的prepare和loop方法。
关于Looper、Handler、Message三者关系，郭神和鸿洋都已写了很好的文章，参考链接如下：
Android异步消息处理机制完全解析，带你从源码的角度彻底理解
Android 异步消息处理机制 让你深入理解 Looper、Handler、Message三者关系

三、RxJava使用示例

RxJava可以很方便的实现在子线程中执行耗时任务，在主线程中更新UI的逻辑：

Observable.just(1)
    .subscribeOn(Schedulers.newThread())
    .observeOn(AndroidSchedulers.mainThread())
    .map {
        // 子线程中执行耗时任务
        it + 1
    }
    .subscribe {
        // 回到了主线程
        Log.d("~~~", "result = $it")
    }

运行程序，Log显示如下：

~~~: result = 2

更多RxJava的使用方式可以参考笔者的另一篇文章：
RxJava2、RxAndroid、RxLifecycle基本使用（Kotlin）
以上，就是Android异步任务的三种方式。