Kotlin之协程

2020-11-05  本文已影响0人  code希必地

1、什么是协程

协程和线程类似，可以简单的理解为一个轻量级的线程。线程是比较重量级的，它需要依靠操作系统来实现线程的切换，而协程的切换是通过编程语言层面进行控制的，大大提高了并发编程的运行效率。

2、协程的基本使用

现在面临的问题是如何开启协程，开启协程的方式有很多种：

2.1、方式一 GlobalScope.launch

GlobalScope.launch {  }

这样我们就成功的开启了一个协程，传递给launch函数的lambda表达式中的代码就运行在协程的环境中了。
GlobalScope.launch创建的是一个顶层协程，相当于创建了一个子线程。下面我们在协程域中打印看下是否是子线程：

fun main() {
    GlobalScope.launch {
        println("ThreadName is ${Thread.currentThread().name}")
    }
    Thread.sleep(100)
    println("ThreadName is ${Thread.currentThread().name}")
}

输出结果如下：

ThreadName is DefaultDispatcher-worker-2 @coroutine#1
ThreadName is main

可见通过GlobalScope.launch创建协程相当于开启了一个子线程。

2.2、方式二 runBlocking

runBlocking {
       println("ThreadName is ${Thread.currentThread().name}")
}

输出结果为：ThreadName is main @coroutine#1，可见通过runBlocking开启协程域并没没有创建线程，依然在主线程中。
再来看下下面代码：

fun main() {
    runBlocking {
        println("create coroutine start")
        delay(4000)
        println("create coroutine end")
    }
    println("run on MainThread")
}

通过运行结果你会发现在协程域中的代码块未执行完成之前，是无法打印run on MainThread，这就说明runBlocking创建的协程是会阻塞其所在的线程的。
delay()函数
我们在代码块中加入了一个delay()函数，它的作用就是使其所在协程暂时挂起，延迟指定时间后再执行协程域内下面的代码，但是它并不会阻塞线程的执行，所以也不会影响其他协程的运行。注意：它只能在协程域中或挂起函数中调用。

2.3、方式三 launch

上面介绍的两种创建协程的方法都是可以在任意地方调用的，但是launch函数只能在协程域下调用，它是用于创建子协程的。子协程的特点是：如果外层作用域的协程结束了，该作用域下的子协程也会全部结束。

fun main() {
    runBlocking {
        launch {
            println("launch1")
            delay(100)
            println("launch1 end")
        }
        
        launch {
            println("launch2")
            delay(100)
            println("launch2 end")
        }
    }
}

这里使用launch创建了两个子协程，运行结果如下：

launch1
launch2
launch1 end
launch2 end

可以看到两个子协程的日志是交替打印的，说明它们确实像多线程那样并发运行的。然而这两个子协程却是在同一个线程中的，只是由编程语言来决定协程间的切换，无须操作系统进行调度，所以协程实现的并发效率高于线程。
但是当launch中的逻辑比较复杂时，我们可能需要将其中的代码抽取出一个个方法，但是这些方法并不在协程的作用域内了，那我们怎么在这些方法中调用像delay()这样的挂起函数呢？
Kotlin中提供了关键suspend来修饰定义挂起函数。

suspend fun printDot(){
        println(".")
        delay(100)
    }

这样我们就定义了一个挂起函数了，由于delay()可以在协程作用域中或挂起函数中调用，所以我们就可以在其中调用delay()了。
虽然suspend能将一个函数声明成挂起函数，但是无法提供协程作用域，所以我们无法在挂起函数中调用launch函数创建子协程。

2.4、方式四 coroutineScope

coroutineScope { }也是一个挂起函数，它的特点是：继承外部的协程作用域并创建一个子作用域(并没有创建子协程，不同于launch)，借助这个特性我们就可以给任意挂起函数提供协程作用域了。示例写法如下：

suspend fun printDot() = coroutineScope {
    launch {
        println(".")
        delay(1000)
    }
}

另外coroutineScope 函数可以保证其作用域内的所有代码和子协程在全部执行完之前，会阻塞当前协程。我们来看如下示例代码：

fun main() {
    runBlocking {
        launch {
            println("launch1 start")
            coroutineScope {
                for (i in 1 until 10)
                    println("$i")
            }
            println("launch1 end")
        }
    }
}

输出如下：

launch1 start
1
2
3
4
5
6
7
8
9
launch1 end

可以看出，coroutineScope函数确实将当前协程阻塞住了。

2.5、方式五 CoroutineScope.launch

前面我们学习了如下四种方式创建协程作用域：

var job:Job?=null
btn_start_coroutine.setOnClickListener {
    job = GlobalScope.launch {
        delay(5000)
        if (job?.isActive == true)
            Log.e(tag, "Global.launch")
    }
}
 override fun onDestroy() {
        super.onDestroy()
        job?.cancel()
}

从上面代码可以看出job?.cancel()并不是真正取消协程，只是给协程设置一个标志位，我们可以通过job?.isActive进行判断协程是否处于运行状态，进而控制协程作用域中代码的运行。
如果我们使用GlobalScope.launch{}创建多个协程，那么在页面关闭时我们就需要多次调用job.cancel()进行协程的取消。这样还是很难管理的，下面看下如何进行统一管理协程：

val job = Job()
val scope = CoroutineScope(job)
scope.launch {
    delay(5000)
    Log.e(tag, "scope.launch")
}

在上面代码中，我们创建一个Job对象，并调用CoroutineScope(job)函数，该函数返回一个CoroutineScope对象，有了这个对象我们就能使用CoroutineScope.launch{}创建协程了，使用这个对象创建的所有协程都是关联到刚才我们创建的job对象的作用域下，这样我们就能使用job.cancel()取消所有协程。

2.6、方式六 async

细心的你肯定发现了上面五种方式是无法获取执行结果的，如果想获取协程的执行结果，就需要使用async{}函数了，下面看下具体使用。

 job = Job()
val scope = CoroutineScope(job!!)
scope.launch {
    val result = async {
        5 + 10
    }.await()
    Log.e(tag,"result is $result")
}

async{}函数只能运行在协程作用域中，其返回的是Deferred对象，如果我们想获取协程的执行结果，就需要调用Deferred.await()方法即可。不过需要注意的是await()在async {}中代码块未执行完成之前会阻塞所在协程执行。如果一个协程作用域下有多个async{}，如果我们在async{}后直接调用await()，这样就会导致多个async{}是串行的，效率低下。我们可以在使用到结果时再调用await()来达到并行的效果。

job = Job()
val scope = CoroutineScope(job!!)
scope.launch {
    val result1 = async {
        1 + 1
    }
    val result2 = async {
        2 + 2
    }
    Log.e(tag, "result is ${result1.await() + result2.await()}")
}

2.7、方式七 withContext

withContext函数只能在协程作用域或挂起函数中调用，它其实是async{}.await()的另一种表现形式。withContext调用时在其中的代码块未执行完成前也会阻塞所在的协程。

job = Job()
val scope = CoroutineScope(job!!)
scope.launch {
    val result = withContext(Dispatchers.Default) {
        5 + 5
    }
    Log.e(tag, "result is $result")
}

可以看到我们在调用withContext()函数时，强制要求我们指定了一个线程参数，下面我们具体讲解下线程参数。

3、线程参数

线程参数主要有如下3个可选项：

4、使用协程简化回调

我们在请求网络获取异步网络数据时，一般是使用回调的方式来实现的，而回调一般都是通过创建匿名内部类来实现的。

HttpUtils.sendRequest(address,object:DataCallBack{
    override fun onFinish(respone:String){
    }
    override fun onError(e:Exception){
    }
})

在多次请求网络数据时就需要多次创建匿名内部类，我们可以是用挂起函数suspendCoroutine来解决这个问题。suspendCoroutine函数是一个挂起函数，必须在协程作用域或挂起函数中调用，它接收一个Lamdba表达式，主要作用是将当前协程挂起，并执行Lambda表达式中的代码块。Lambda表达式的参数列表上会传入一个Continuation对象，可以调用其resume()方法或者resumeWithException()让协程恢复运行。

 suspend fun request(address: String): String = suspendCoroutine {
            sendRequest(address, object : DataCallback {
                override fun onFinish(response: String) {
                    it.resume(response)
                }
                override fun onError(e: Exception) {
                    it.resumeWithException(e)
                }

            })
        }

从上面代码可以看出使用suspendCoroutine{}进行网络请求其内部还是需要创建匿名内部类来实现回调，只不过在调用sendRequest()时在编码上省略了这个操作。

try {
    val response = request("http://www.baidu.com")
} catch (e: Exception) {
    //对异常的处理
}

request函数是一个挂起函数，当调用该函数时，协程就会被挂起，当等待网络请求成功或失败，协程才会恢复运行。这样即使不使用回调的写法，我们也能获取异步请求网络的数据，而如果请求失败，则会直接进入catch语句中。

上一篇下一篇

猜你喜欢

热点阅读