AsyncTask被废弃了，换Coroutine吧
本文主要是学习笔记，有版权问题还请告知删文
鸣谢：guolin@第一行代码（第三版）
你是否也在最近的代码中看见了 AsyncTask 被一条横杠划掉了
这表明——他要被Google放弃了
Google说让我们换成协程，也就是Coroutine，我们来看看怎么无缝切换
1. 添加依赖
首先，他并不是在标准库里，所以我们要添加依赖
dependencies {
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.3.7"
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.7"
}
2. 使用协程
2.1 GlobalScope.launch
最简单的方法就是调用GlobalScope.launch
这里每创建一个协程都是顶层协程！对！没错！协程是分层级
GlobalScope.launch {
//do something
}
这个函数的特点就是：自己闷头执行，主线程结束，他也结束（虽然有可能没执行完）
2.2 runBlocking
runBlocking从字面意思就可以理解，运行并阻塞，意思是运行协程，并在携程未结束时阻塞当前线程
runBlocking{
//do something
}
这个函数的特点就是：执行时阻塞当前线程
此方法一般用在测试环境，实际使用中容易有性能问题
2.3 多协程
多协程只要我们这么写就可以
runBlocking{
launch{
//do something#1
}
launch{
//do something#2
}
launch{
//do something#3
}
}
这样我们就创建了3个子协程
注意，我们这里的launch和GlobalScope.launch有一些区别，GlobalScope创建的是顶层协程
另外，我们的多协程还是运行在一个线程里面的，也就是3个协程运行在一个线程里面
到这里，相信你们都有了一种奇怪的感觉，一个线程里实现并发？？？
我要说的是：没错！
因此它不需要操作系统的参与，像是子协程有一百万个，它也不会产生OOM
我测试了1000000个协程总共消耗了5722ms，也就是5秒
高并发效率非常高
2.4 suspend关键字（能在协程里调用的函数）
别担心，这跟Java废弃的那个强制挂起线程的函数没什么关系，只是恰巧长得一样而已@Java suspend()
当你的代码过多导致可读性很差的时候，就需要将部分代码写成一个函数，这时候就需要用到suspend，这样我们就可以在协程作用域里面调用该函数
用guolin大神的话说，就是“suspend可以将我们的函数声明成挂起函数”
我理解的是，挂起函数可以在其内部调用其他的挂起函数，比如：delay()
suspend fun 函数名(参数列表){
//do something
}
但是suspend并不会让我们的函数就像在协程作用域里写的一样，比如：无法调用launch创建子协程
这时我们就需要调用corountineScope函数
suspend fun 函数名(参数列表) = corountineScope{
launch{
//do something
}
}
corountineScope 是会在其作用域里的程序执行完成前阻塞当前协程的，但它不会影响其他协程，也不会影响线程
而且它只能在 协程作用域 或 挂起函数 下调用
runBlocking {
launch {
println("即将被阻塞")
coroutineScope{
for (i in 1..3){
println("阻塞中")
delay(10)
}
}
println("阻塞结束")
}
launch {
println("我没被阻塞")
}
}
这个运行结果就会是这样的
即将被阻塞
阻塞中
我没被阻塞
阻塞中
阻塞中
阻塞结束
3. 取消协程（关掉它！！！）
launch函数会返回一个Job类型的对象
Job类里面有一个cancel函数，调用它就可以取消协程
val job = Job()
val scope = CoroutineScope(job)
scope.launch{
//do something
}
job.cancel()
这就是一般情况下项目里协程的写法
这里还有一个要注意的，第二行的CoroutineScope(job)并不是CoroutineScope的构造函数，而是一个单独的函数
至于为啥Kotlin要把这个函数名首字母大写，我也不知道...
4. 获得协程运行结果
4.1 async
假设我们在需要进行一个耗时操作，我们将这个任务放到协程里，可我们不知道什么时候能获得这个结果，而launch最终也只是返回一个Job对象，这样的机制不利于我们处理结果，所以为了获得我们需要的结果，async函数就必不可少了，async会新建一个子协程并返回一个Deferred对象，Deferred里有一个await函数，他就会给我们想要的结果
还有一点相信你已经想到了，await会阻塞当前的协程，直到获得我们想要的结果
写法如下
runBlocking {
val result = async {
//do something
}.await()
}
其中常量result就是我们需要的结果
这里需要注意的是，如果你有多个结果需要获取，一定要明白其中的逻辑关系然后优化好代码
比如：我们需要用A和B生成E，C、D生成F，E、F生成result
代码就应该这么写
val job = Job()
val scope = CoroutineScope(job)
scope.launch {
val E = async {
//A和B生成E
}
val F = async {
//C和D生成F
}
val result = async {
//E.await() 和 F.await() 生成
}
}
4.2 withContext
写法如下
runBlocking {
val result = withContext(Dispatchers.Default) {
//do something
}
}
还是引用guolin大神的话：withContext可以理解为async的简化版写法。
调用 withContext 会立刻执行代码块里的代码，同时将当前的协程阻塞。代码块执行完后，会将最后一行的结果当做返回值返回。唯一不同的是他有个参数。
简而言之，就是没有 await 函数，没法灵活控制协程阻塞，除此之外多了个参数，其他和async区别不大
guolin大神还说了：withContext是强制要求输入参数的。而刚才提到的除了coroutineScope，其他所有的协程作用域构建器也都可以指定参数，只不过不强制
那么这个参数是干嘛的呢？？？
答案是用来选择并发线程策略的，这种参数主要有三种可选：Dispatchers.Default、Dispatchers.IO、Dispatchers.Main
是的，你没听错，线程策略，是线程，也就是说，他会创建线程来帮助实现并发，要知道网络请求是只能在线程里实现并发的，协程是不行的。
| Dispatchers.Default | 默认的低并发线程策略 |
|---|---|
| Dispatchers.IO | 高并发线程策略 |
| Dispatchers.Main | 不开启线程 |
5. 回调简写（suspendCoroutine）
我们回调的通常写法是：
HttpUtil.sendHttpRequest(address : String , object : HttpCallbackListener {
override fun onFinish() {
//do something
}
override fun onError() {
//do something
}
})
类似这样，代码就很多，动个手指头都嫌累
Kotlin就给了我们一个解决策略
用suspendCoroutine函数！
suspendCoroutine必须在协程域中或挂起函数里调用
它接受一个lambda表达式参数，主要作用是将当前协程立刻挂起，然后在一个普通线程（guolin大神的话，我理解的是非主线程就行）里执行lambda表达式中的代码。
lambda表达式又传入一个Continuation参数，调用它的resume() 或 resumeWithException() 就可以让协程恢复执行。
代码示例：
suspend fun request(address: String): String {
return suspendCoroutine { contination ->
HttpUtil.sendHttpRequest(address, object : HttpCallbackListener {
override fun onFinish(Response: String) {
contination.resume(Response)
}
override fun onError(e: Exception) {
contination.resumeWithException(e)
}
})
}
}
然后你就想骂我，这TM不是更多了吗？？？
你调用试试...
suspend fun getBaiduResult(){
try{
val result = request ( "https://www.baidu.com" )
//对result进行处理
}catch{
//异常处理
}
}
爽不爽！？
