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 onAccept(value: String) {
                                //这里是主线程并协带结果
                                Log2.e("onASync:$value")
                                val temp = if (Looper.getMainLooper() == Looper.myLooper()) "主线程" else "子线程"
                                Log2.e("onAccept:$temp")
                            }
                        })

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

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

倒计时：倒计时一分钟这样实现

QuickASync.async(object : QuickASync.OnIntervalListener<Int> {
                            override fun onNext(value: Int) {
                               //每隔一秒执行一次，主线程
                            }

                            override fun onAccept(value: Int) {
                                //完成后执行
                            }
                        }, 1000, 60, true)

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

QuickASync.async(object : QuickASync.OnIntervalListener<Int> {
                            override fun onNext(value: Int) {
                               //每隔一秒执行一次，主线程
                            }

                            override fun onAccept(value: Int) {
                                //完成后执行
                            }
                        }, 1000, 60, false)

有时也需要迟延执行代码

QuickASync.async({
            //这里执行
        }
        ,1000)

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

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

推荐使用gradle接入

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

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

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