QuickASync使用详解-快速切换子线程处理耗时操作，执行完成后回归主线程

QuickASync是什么东西呢，顾名思义快速切换子线程处理耗时操作，执行完成后回归主线程，听起来挺洋气的。

 那此组件有什么特点：

做异步操作时，只需要调用一个方法即可，简单快速做异步操作，并且组件轻巧，几百行代码，不用担心apk体积增加太大，不与现有代码冲突。

接下来我们看一下正常写法：

1、定义一个handler-并处理业务逻辑

val handler = @SuppressLint("HandlerLeak")
    object : Handler() {
        override fun handleMessage(msg: Message?) {
            super.handleMessage(msg)
            when (msg?.what) {
                123 -> {
                    val bundle = msg.data
                    QuickToast.showToastDefault(String.format("收到一个ID:%s", bundle.getString("id")))
                }
            }
        }
    }

2、定义一个thread-并处理业务逻辑

val thread = object : Thread() {
        override fun run() {
            super.run()
            Thread.sleep(2000)
            val msg = Message()
            val bundle = Bundle()
            bundle.putString("id", "123")
            bundle.putString("max", "this is a max")
            msg.data = bundle
            msg.what = 123
            handler.sendMessage(msg)
        }
    }

3、在需要的地方调用子线程

thread.start()

这种方法也说不上麻烦，只是感觉代码冗余，太多重复，不够优雅。

那么，请看下QuickASync的写法

 同样的做异步操作

QuickAsync.async(object : QuickAsync.OnASyncListener<String> {
    override fun onASync(): String {
        return if (Looper.getMainLooper() == Looper.myLooper()) "主线程" else "子线程"
    }

    override fun onError(O_O: Exception) {//如果onAsync里面发生异常，将在这里触发
        super.onError(O_O)
    }
    
    override fun onAccept(value: String) {//执行成功，在这里处理结果，并且这里是主线程
        Log2.e("onASync:$value")
        val temp = if (Looper.getMainLooper() == Looper.myLooper()) "主线程" else "子线程"
        Log2.e("onAccept:$temp")
    }
})

这种方式一步到位，逻辑清晰，优势很明显，组件已经将线程池定义好，直接使用，提升效率。

组件还定义一些实用的方法

使用比较多的，切换到主线程。

QuickAsync.runOnUiThread { 
    //这里就是主线程了，可以愉快的操作UI了
}

计时操作，很多时候app会用到计时操作，比如，秒表、验证码计时、广告计时等。

那么计时60秒可以这么写

val test = QuickAsync.asyncTime(object : QuickAsync.OnIntervalListener<Long> {
    override fun onNext(value: Long) {
        sampleTv3.text = String.format("异步计时(%d)", value)
    }

    override fun onAccept(value: Long) {
        sampleTv3.text = "异步计时(End)"
    }
}, 1000, 60, true)//间隔1秒，走60次，正序，从小到大1-60

QuickAsync.asyncDelay({
    /*5秒执行，暂停*/
    test.cancel(true)
}, 5000)

如果倒计时呢？很简单，将最后一个参数置为false或者不填

val test = QuickAsync.asyncTime(object : QuickAsync.OnIntervalListener<Long> {
    override fun onNext(value: Long) {
        sampleTv3.text = String.format("异步计时(%d)", value)
    }

    override fun onAccept(value: Long) {
        sampleTv3.text = "异步计时(End)"
    }
}, 1000, 60, false)

有时也需要迟延执行代码

QuickASync.asyncDelay({
            //这里执行，这里也是主线程哟
        },1000)

还有循环执行代码，不主动停止，永不停止

val task=QuickAsync.asyncLoop({steps ->
    //do something
}, 1000L)//每秒操作一次

task.cancel()//在不需要的地方，调用取消

使用起来很方便，有木有。

以上便是简单的异步操作，如果有需要更复杂的使用场景，推荐使用RxAndroid

推荐使用gradle接入

implementation 'org.quick.android:quick-component:latest.release'

 统一初始化放在Application中：

QuickAndroid.init(this)

源码地址：https://github.com/SpringSmell/quick-component

好了，到这里就结束，好东西那当然要分享了，马上告诉小伙伴我发现了一个很酷的东西吧。

QuickAndroid系列全家桶