Koltin协程Coroutines进阶，初步替代Rxjava

可以先看这篇入门教程
Koltin协程，Coroutines入门
demo git
demo rar

Rxjava就不说了，毋庸置疑很强大，但是用起来很繁琐，从大型社区的关注度可以看出也在慢慢的退出历史舞台。Rxjava中提供大量的操作符，对于初学者来说使用起来颇为复杂，下面我们来试试怎么用Coroutines来替代使用Rxjava操作符。

Android的UI刷新不能在主线程进行，异步回调更新UI需要使用handler，runOnActivity，或者使用Rxjava来进行线程更换，不管使用何种方式，都显得很累赘，我们看看Koltin Coroutines 怎么实现。

异步回调

先看看java里面，线程怎么实现的。Rxjava不做说明，请自行了解。

public class MyThread implements Runnable {
    
    

     interface Callback{
    
    
        <T> void backResult(T t);
    }

    private  Callback callback;


    public MyThread(Callback callback) {
    
    
        this.callback = callback;
    }

    @Override
    public void run() {
    
    
        //耗时操作
        callback(...);
    }
}

kotlin实现

     GlobalScope.launch {
    
    
            //耗时操作
            val async = async {
    
    
                delay(3000)
                return@async "666"
            }
            //result 就是异步回调的值
            var result = async.await()
        }

这个代码量，看起来是不是很棒！
接下来我用它来实现稍微复杂一些的操作。

合并多次异步请求的返回值

			 /**
             * 场景一
             * 需要合并两个异步运算后的结果。
             * 如组合提取多个网络请求的返回值。
             */
            GlobalScope.launch {
    
    
                val async1 = async {
    
    
                    delay(3000)
                    return@async 666
                }
                val async2 = async {
    
    
                    delay(2000)
                    return@async "Async Return:"
                }
                val result = async2.await() + async1.await()
                //await()，就是表示异步回调到主线程了，直接使用该值进行UI更新textview。
                TextView.text = result
                Log.d("MainActivity", "RUN----> Time:${
      
      Util.getNow()}, Result:$result")
            }

两个异步操作，一个耗时2s，一个耗时3s，但最终执行完毕已最长3s那个为准

获取异步返回值进行接下去操作

			/**
             * 场景二
             * 根据第一个异步操作的值，来进行接下来操作。
             * 如 注册成功后直接进行登录。
             */
            GlobalScope.launch {
    
    
                val result = async {
    
    
                    val async1 = job1()
                    if (async1 == "Async1-") {
    
    
                        val async2 = job2()
                        return@async async1 + async2
                    }
                    return@async async1
                }
                //await()，就是表示异步的回调，直接使用该值进行UI更新
                TextView.text = result.await()
                Log.d("MainActivity", "RUN----> Time:${
      
      Util.getNow()}, Result:${
      
      result.await()}")
            }

两个异步操作，如果满足条件执行顺序执行，如不满足执行顶层方法。

取消协程

  			 /**
             * 场景三
             * 主動断开请求
             * 如 断开某个心跳线程。
             */

            GlobalScope.launch {
    
    
                task = async {
    
    
                    while (true) {
    
    
                        heartBeat++
                        Log.d("MainActivity", "RUN----> Time:${
      
      Util.getNow()},发送心跳包。")
                        delay(1000)
                    }
                }
            }

      fun{
    
    
            task?.cancel()
            Log.d("Test", "MainActivity: 取消心跳包发送 一直进行$heartBeat 次")
      }	

通过手动调用来取消。