Kotlin学习笔记(五)－－kotlin的协程

迈不过友情╰ 2023-07-21 06:14 21阅读 0赞

总结：协程就是 Kotlin 提供的一套线程封装的 API

`Java`中的并发操作例子：

new Thread(new Runnable() { 
        @Override
        public void run() { 
            //耗时任务
        }
    }).start();

`kotlin`中线程的例子：

Thread { 
        //耗时任务
    }.start()

同`java`一样，不知道线程何时结束和执行结果

高级一点，在`java`中可以使用线程池`Executor`来管理线程，例根据需要创建新线程的线程池

ExecutorService es = Executors.newCachedThreadPool();
    es.submit(new Runnable() { 
        @Override
        public void run() { 
            //耗时任务
        }
    });

同样可以在`kotlin`中使用

val es: ExecutorService = Executors.newCachedThreadPool()
    es.execute({ 
        //耗时任务
    })

在`kotlin`中也可以使用`Android`的`AsyncTask`来处理线程间的通信

object : AsyncTask<T0, T1, T2> { 
        override fun doInBackground(vararg args: T0): String {  ... }
        override fun onProgressUpdate(vararg args: T1) {  ... }
        override fun onPostExecute(t3: T3) {  ... }
    }

可以看到，使用`Android`的方法，强制的把线程切换设成了前台，后台，更新三个步骤，多层嵌套就更麻烦了。  
可以使用`RxJava`和`kotlin 的协程`来简化逻辑和代码，比如使用`协程`

launch({
        val user = api.getUser() //  网络请求（IO 线程）
        nameTv.text = user.name  //  更新 UI（主线程）
    })

# 协程的好处 #

## 闭包原则 ##

创建线程

//正常写法
    Thread(object : Runnable { 
        override fun run() { 
        	//耗时任务
        }
    })
    //定义了SAM的接口，使得以其为参数的方法，可以在调用时，使用一个lambda表达式作为参数
    //可以简化为
    Thread({ 
        //耗时任务
    })
    //使用闭包，简化为
    Thread { 
        //耗时任务
    }

在 Kotlin 中有这样一个语法糖：当函数的最后一个参数是 lambda 表达式时，可以将 lambda 写在括号外。这就是它的闭包原则。

`launch` 函数，可以通过闭包来进行简化

## 创建线程的方式 ##

// 方法一，使用 runBlocking 顶层函数
    runBlocking { 
        // do sth
    }
    
    // 方法二，使用 GlobalScope 单例对象
    // 可以直接调用 launch 开启协程
    GlobalScope.launch { 
        // do sth
    }
    
    // 方法三，自行通过 CoroutineContext 创建一个 CoroutineScope 对象
    // 需要一个类型为 CoroutineContext 的参数 比如Dispatchers.Main 和 Dispatchers.IO
    val coroutineScope = CoroutineScope(context)
    coroutineScope.launch { 
        // do sth
    }

三种方式的优缺点

方法一通常适用于单元测试的场景，而业务开发中不会用到这种方法，因为它是线程阻塞的。
    方法二和使用 runBlocking 的区别在于不会阻塞线程。但在 Android 开发中同样不推荐这种用法，因为它的生命周期会和 app 一致，
    且不能取消。
    方法三是比较推荐的使用方法，我们可以通过 context 参数去管理和控制协程的生命周期（这里的 context 和 Android 里的不是
    一个东西，是一个更通用的概念，会有一个 Android 平台的封装来配合使用）。

## 常用方法 ##

协程最常用的功能是`并发`，多用在`线程切换`，例

coroutineScope.launch(Dispatchers.Main) {        // 开始协程：主线程
        val token = api.getToken()                  // 网络请求：IO 线程
        val user = api.getUser(token)               // 网络请求：IO 线程
        nameTv.text = user.name                     // 更新 UI：主线程
    }

如果是多个网络请求，根据两个请求的结果来主线程展示

coroutineScope.launch(Dispatchers.Main) { 
        val avatar = async {  api.getAvatar(user) }    // 获取用户头像
        val logo = async {  api.getCompanyLogo(user) } // 获取用户所在公司的 logo
        val merged = suspendingMerge(avatar, logo)    // 合并结果 调用非阻塞式挂起的函数 使用 suspend修饰
        show(merged) // 更新 UI
    }

协程切换线程过程可使用`withContext`函数，执行后自动切换回原有线程

coroutineScope.launch(Dispachers.Main) {  //主线程
        ...
        withContext(Dispachers.IO) {  //切到子线程执行，执行完切回主线程
            ...
        }
        ... //主线程
        withContext(Dispachers.IO) {  //切到子线程执行，执行完切回主线程
            ...
        }
        ... //主线程
    }

`suspend`关键字，`非阻塞式挂起`