Android - kotlin 协程极简入门

Myth丶恋晨 2022-12-10 03:56 232阅读 0赞

# 背景 #

> 协程的作用是解决并发，并发的常见场景是多线程。

“并发”和“并行”经常弄混。下面是我的理解，当然我理解也不一定是对的

> “并发”是宏观上多个任务同时执行，而微观上任务是同一时间只有一个在执行。而“并行”不管宏观微观都是多个任务在同时执行。  
> 举个生活中的例子：“并发”就像是吃饭的时候讲话，微观上同一时间只能是吃饭或者是讲话，是一个人在执行。“并行”就是让一个人吃饭，另一个人去讲话，是两个人去执行。

多线程情况下就不可避免的涉及以下的问题：

*  线程什么时候执行结束
 *  线程间的相互通信
 *  多个线程的管理

在以往的开发中我们可以是通过下面的代码开启线程或者使用线程池来管理线程：

Thread{ 
    	// 子线程操作
    }.start()
    
    // 线程池
    val newCachedThreadPool = Executors.newCachedThreadPool()
    newCachedThreadPool.execute { 
        // 执行耗时
    }

而线程间的通信可以通过`AsyncTask`或者 `Handler`去通信，但是操作都会相当麻烦，代码量增多。

// AsyncTask
    class MyAsyncTask: AsyncTask<URL, Int, Long>() { 
        override fun doInBackground(vararg params: URL?): Long { 
            // 执行耗时操作
            Log.e(TAG,"doInBackground")
            return 1L
        }
    }
    
    MyAsyncTask().execute()
    
    
    
    
    // Handler
    class MyHandler:Handler(){ 
        private val TAG = MyHandler::class.java.simpleName
        override fun handleMessage(msg: Message?) { 
            super.handleMessage(msg)
            Log.e(TAG,"handleMessage what:${msg?.what}")
            Log.e(TAG,"handleMessage obj:${msg?.obj}")
        }
    }
    
    
    val message = Message()
    message.what = 0
    message.obj = "message"
    MyHandler().sendMessage(message)
    
    MyHandler().post { 
        Log.e(TAG,"post")
    }

使用 `kotlin 协程`可以解决以上这些问题！

# 引入依赖 #

// 协程核心库
    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.1'
    // 依赖当前平台所对应的平台库
    implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.1"

# 使用 #

## 创建协程 ##

大部分情况下，我们都是用 launch 函数来创建协程，其实还有其他两个函数也可以用来创建协程：

*  runBlocking
 *  async

runBlocking 函数 通常适用于单元测试的场景，而业务开发中不会用到这个函数，因为它会阻塞当前线程。  
大部分的代码都是阻塞线程的，只是有的阻塞时长在 UI 上肉眼不可见，有的肉眼可见。

对应的还有非阻塞线程 函数 launch 和 async 。

接下来我们主要来对比 launch 与 async 这两个函数。

*  相同点：它们都可以用来启动一个协程，返回的都是 Coroutine
 *  不同点：async 返回的 Coroutine 实现了 Deferred 接口，调用 Deferred.await() 就可以得到结果了。

### launch 示例 ###

> 执行耗时操作后将结果返回给 UI 展示

CoroutineScope(Dispatchers.Main).launch { 
        // readMeterAddress 是耗时操作
        val data =  readMeterAddress()
        // UI 刷新结果
        tv_result.text = data
    }
    
    private suspend fun readMeterAddress():String{ 
        return withContext(Dispatchers.IO){ 
            // TODO 耗时操作
        	delay(3000)
    		
    		"address"
        }
    }

### async 示例 ###

> 执行耗时操作后将结果返回给 UI 展示

CoroutineScope(Dispatchers.Main).launch { 
    
        val data = async {  readMeterDate() }
    
        // 通过 await() 获取数据
        tv_result.text = data.await()
    }
    
    private fun readMeterDate():String{ 
    	// TODO 耗时操作
    
        return "date"
    }

前面的方法中用到了 `suspend` 关键字

## suspend ##

> kotlin 协程关键字，仅起提示作用，提示该函数是一个耗时函数，请在协程里调用

耗时操作一般分为两类：

*  I/O 操作，CPU 计算工作：比如文件的读写、网络交互、图片的模糊处理，
 *  等待操作：比如延迟 5 秒钟之后做其它任务

`withContext(context: CoroutineContext)`挂起函数，可以指定在哪个线程环境执行任务。  
常用的 Dispatchers ，有以下三种：

*  Dispatchers.Main：Android 中的主线程
 *  Dispatchers.IO：针对磁盘和网络 IO 进行了优化，适合 IO 密集型的任务，比如：读写文件，操作数据库以及网络请求
 *  Dispatchers.Default：适合 CPU 密集型的任务，比如计算

// 定义 suspend
    private suspend fun withContextData(){ 
        // 挂起5秒之后再执行后面的操作
        withContext(Dispatchers.IO){ 
            Log.e(TAG,"去做 IO　操作")
        }
    }
    
    // 调用
    CoroutineScope(Dispatchers.Main).launch { 
        withContextData()
    }

`delay(timeMillis: Long)`挂起函数，可以将协程挂起指定时间

// 定义 suspend 
    private suspend fun delayData(){ 
        Log.e(TAG,"before readData:"+System.currentTimeMillis())
        // 挂起5秒之后再执行后面的操作
        delay(5000)
        Log.e(TAG,"after readData:"+System.currentTimeMillis())
    }
    
    // 调用
    CoroutineScope(Dispatchers.Main).launch { 
       
        delayData()
    }

不管是 `withContext` 还是 `delay` 它实质上会往你的主线程 `post` 一个 `Runnable`，这个 `Runnable` 中的代码就是你的协程代码

# 总结 #

## 本质 ##

*  kotlin 协程本质上是线程框架
 *  kotlin 协程的挂起本质是线程切换

## 使用 ##

先引入依赖，然后使用非阻塞式调用 `CoroutineScope(指定执行的环境).launch{}`开启协程。

指定的执行环境有三种：

*  `IO`：子线程执行，耗时计算
 *  `MAIN`：主线程执行
 *  `Default`：子线程执行，适合密集型的计算

在 `launch` 代码块中可执行挂起函数，通过 `suspend` 定义，该关键字仅起提示作用，用于声明耗时函数。

而耗时操作常见的有两种类型：

*  `IO`耗时
 *  等待耗时

`IO` 耗时可以通过 `withContext(Dispatchers.IO)` 去执行  
等待耗时可以通过 `delay(等待时间)` 去执行

# 参考 #

*  [Kotlin 的协程用力瞥一眼 - 学不会协程？很可能因为你看过的教程都是错的][Kotlin _ -]
 *  [Kotlin 协程的挂起好神奇好难懂？今天我把它的皮给扒了][Kotlin]
 *  [到底什么是「非阻塞式」挂起？协程真的更轻量级吗？][Link 1]

[Kotlin _ -]: https://kaixue.io/kotlin-coroutines-1/
[Kotlin]: https://kaixue.io/kotlin-coroutines-2/
[Link 1]: https://kaixue.io/kotlin-coroutines-3/