Kotlin协程(1)

一 简介

Kotlin中的协程是由kotlinx.coroutines这个库来实现的
特点：
1.代码可读性性好，不用回调函数,简化异步编程，提高效率。
2.在语言级别支持，在标准库中只提供最低级程度的APIs,功能放到coroutines库中。
3.轻量：单个线程上运行多个协程，因为协程支持挂起，不会使正在运行协程的线程阻塞。挂起比阻塞节省内存，且支持多个并行操作。
4.内存消耗更少：使用结构化并发机制在一个作用域内执行多项操作。
5.内置取消支持：取消操作会自动在运行中的整个协程层次结构内传播。
6.jetpack集成：许多Jetpack库都包含提供全面协程支持的扩展。某些库还提供自己的协程作用域，可供结构化开发。

二 协程基础

使用：

添加依赖：

dependencies {
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.9'
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7"
}

示例代码：

class LoginViewModel(
    private val loginRepository: LoginRepository
): ViewModel() {

    fun login(username: String, token: String) {
        // Create a new coroutine to move the execution off the UI thread
        viewModelScope.launch(Dispatchers.IO) {
            val jsonBody = "{ username: \"$username\", token: \"$token\"}"
            loginRepository.makeLoginRequest(jsonBody)
        }
    }
}

viewModelScope:
viewModelScope包含在ViewModel KTX扩展中，所有的协程必须在一个CoroutineScope内，一个CoroutineScope管理一个或多个相关的协程。
launch:
创建协程，并将起函数主体的执行分派给相应的调度程序
Dispatchers.IO:
指示此协程应在为 I/O 操作预留的线程上执行

二 协程作用域：

可以使用coroutineScope脚本来构建一个协程作用域，coroutineScope并不会创建新的协程而是执行在当前协程且它是一个suspend函数，coroutineScope代码块内的代码执行在外层的协程中，在coroutineScop内可以启动新的协程，注意当所有子协程执行完了后coroutineScope才算是执行完，只要有一个子协程出现异常，所有coroutineScope内的其他子协程都会取消。
常用作用域：
GlobalScope：
非阻塞协程构造器，生命周期受整个应用程序的生命周期限制，且不能取消
lifecycleScope:
lifecycleScope只能在Activity、Fragment中使用，会绑定Activity和Fragment的生命周期
viewModelScope:
非阻塞协程构造器，通过 context 参数去管理和控制协程的生命周期声明自己作用域，它会创建一个协程作用域并且在所有已启动子协程执行完毕之前不会结束
其它：
suspend:
所有的suspend函数必须在协程中执行,suspend是一个挂起函数，作用是暂停执行当前协程，并保存所有局部变量。

三 线程调度器：

每个协程的上下文都有一个调度器
Dispatchers.Main：
指定主线程, 用来做UI更新相关的事情. (需要添加依赖, 比如kotlinx-coroutines-android.) 如果我们在主线程上启动一个新的协程时, 主线程忙碌, 这个协程也会被挂起, 仅当线程有空时会被恢复执行.
Dispatchers.IO：
此调度程序经过了专门优化，适合在主线程之外执行磁盘或网络 I/O，从文件中读取数据或向文件中写入数据，以及运行任何网络操作。
Dispatchers.Default:
代表使用JVM上的共享线程池，其大小由CPU核心数决定，不过即便是单核也有两个线程，通常用来做CPU密集型工作，比如排序或复杂计算等。
Dispatchers.Unconfined:
不指定特定线程, 这是一个特殊的dispatcher.

三 协程的通信

channel是一个并发安全的队列，它可以用来连接协程实现不同协程之间的通信。

生产者消费者模式

两个协程发送的协程是producer,接受数据的协程是consumer.
生产者消费者可以是以对多，也可以是多对多的关系

 suspend fun demo(){
        val channel = Channel()
        val producer = GlobalScope.launch{
            var postion = 0
            while (true){
                channel.send(postion++)
                delay(500)
            }
        }
        val consumer = GlobalScope.launch{
            while(true){
                val element = channel.receive()
            }
        }
        producer.join()
        consumer.join()
    }

channel的关闭操作

    suspend fun demo(){
        val channel = Channel()
        val producer = GlobalScope.launch{
            var postion = 0
            while (true){
                channel.send(postion++)
                delay(500)
                if (postion>5){
                    channel.close()
                    break
                }
            }
        }
        val consumer = GlobalScope.launch{
            while(true){
                val element = channel.receive()
            }
        }
        producer.join()
        consumer.join()
    }

channel关闭的意义
如果不关闭channel会造成内存泄露吗？答案不会的，它不像io，Channel 其实内部的资源是个缓冲区，是一块内存,如果开了而不去关闭它是不回造成内存泄露的。它更像是一种约定，就像两个人，A说帮我买一瓶牛奶，B回答 好的。