什麼是協程?
官方描述:協程通過將複雜性放入庫來簡化異步編程。程序的邏輯可以在協程中順序地表達,而底層庫會爲我們解決其異步性。該庫可以將用戶代碼的相關部分包裝爲回調、訂閱相關事件、在不同線程(甚至不同機器)上調度執行,而代碼則保持如同順序執行一樣簡單。
協程就像非常輕量級的線程。線程是由系統調度的,線程切換或線程阻塞的開銷都比較大。而協程依賴於線程,但是協程掛起時不需要阻塞線程,幾乎是無代價的,協程是由開發者控制的。所以協程也像用戶態的線程,非常輕量級,一個線程中可以創建任意個協程。
協程很重要的一點就是當它掛起的時候,它不會阻塞其他線程。協程底層庫也是異步處理阻塞任務,但是這些複雜的操作被底層庫封裝起來,協程代碼的程序流是順序的,不再需要一堆的回調函數,就像同步代碼一樣,也便於理解、調試和開發。它是可控的,線程的執行和結束是由操作系統調度的,而協程可以手動控制它的執行和結束。
使用
首先需要添加依賴:
implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.1.1"
1.runBlocking:T
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.e(TAG, "主線程id:${mainLooper.thread.id}")
test()
Log.e(TAG, "協程執行結束")
}
private fun test() = runBlocking {
repeat(8) {
Log.e(TAG, "協程執行$it 線程id:${Thread.currentThread().id}")
delay(1000)
}
}
runBlocking
啓動的協程任務會阻斷當前線程,直到該協程執行結束。當協程執行結束之後,頁面纔會被顯示出來。
2.launch:Job
這是最常用的用於啓動協程的方式,它最終返回一個Job類型的對象,這個Job類型的對象實際上是一個接口,它包涵了許多我們常用的方法。下面先看一下簡單的使用:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
Log.e(TAG, "主線程id:${mainLooper.thread.id}")
val job = GlobalScope.launch {
delay(6000)
Log.e(TAG, "協程執行結束 -- 線程id:${Thread.currentThread().id}")
}
Log.e(TAG, "主線程執行結束")
}
//Job中的方法
job.isActive
job.isCancelled
job.isCompleted
job.cancel()
jon.join()
從執行結果看出,
launch
不會阻斷主線程。
我們看一下launch
方法的定義:
public fun CoroutineScope.launch(
context: CoroutineContext = EmptyCoroutineContext,
start: CoroutineStart = CoroutineStart.DEFAULT,
block: suspend CoroutineScope.() -> Unit
): Job {
val newContext = newCoroutineContext(context)
val coroutine = if (start.isLazy)
LazyStandaloneCoroutine(newContext, block) else
StandaloneCoroutine(newContext, active = true)
coroutine.start(start, coroutine, block)
return coroutine
}
從方法定義中可以看出,
launch()
是CoroutineScope的一個擴展函數,CoroutineScope簡單來說就是協程的作用範圍。launch
方法有三個參數:1.協程下上文;2.協程啓動模式;3.協程體:block
是一個帶接收者的函數字面量,接收者是CoroutineScope
1.協程下上文
上下文可以有很多作用,包括攜帶參數,攔截協程執行等等,多數情況下我們不需要自己去實現上下文,只需要使用現成的就好。上下文有一個重要的作用就是線程切換,Kotlin協程使用調度器來確定哪些線程用於協程執行,Kotlin提供了調度器給我們使用:
-
Dispatchers.Main:使用這個調度器在 Android 主線程上運行一個協程。可以用來更新UI 。在UI線程中執行
-
Dispatchers.IO:這個調度器被優化在主線程之外執行磁盤或網絡 I/O。在線程池中執行
-
Dispatchers.Default:這個調度器經過優化,可以在主線程之外執行 cpu 密集型的工作。例如對列表進行排序和解析 JSON。在線程池中執行。
-
Dispatchers.Unconfined:在調用的線程直接執行。
調度器實現了CoroutineContext接口。
2.啓動模式
在Kotlin協程當中,啓動模式定義在一個枚舉類中:
public enum class CoroutineStart {
DEFAULT,
LAZY,
@ExperimentalCoroutinesApi
ATOMIC,
@ExperimentalCoroutinesApi
UNDISPATCHED;
}
一共定義了4種啓動模式,下表是含義介紹:
啓動模式 | 作用 |
---|---|
DEFAULT | 默認的模式,立即執行協程體 |
LAZY | 只有在需要的情況下運行 |
ATOMIC | 立即執行協程體,但在開始運行之前無法取消 |
UNDISPATCHED | 立即在當前線程執行協程體,直到第一個 suspend 調用 |
2.協程體
協程體是一個用suspend關鍵字修飾的一個無參,無返回值的函數類型。被suspend修飾的函數稱爲掛起函數,與之對應的是關鍵字resume(恢復),注意:掛起函數只能在協程中和其他掛起函數中調用,不能在其他地方使用。
suspend函數會將整個協程掛起,而不僅僅是這個suspend函數,也就是說一個協程中有多個掛起函數時,它們是順序執行的。看下面的代碼示例:
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
GlobalScope.launch {
val token = getToken()
val userInfo = getUserInfo(token)
setUserInfo(userInfo)
}
repeat(8){
Log.e(TAG,"主線程執行$it")
}
}
private fun setUserInfo(userInfo: String) {
Log.e(TAG, userInfo)
}
private suspend fun getToken(): String {
delay(2000)
return "token"
}
private suspend fun getUserInfo(token: String): String {
delay(2000)
return "$token - userInfo"
}
getToken
方法將協程掛起,協程中其後面的代碼永遠不會執行,只有等到getToken
掛起結束恢復後纔會執行。同時協程掛起後不會阻塞其他線程的執行。
3.async
async跟launch的用法基本一樣,區別在於:async的返回值是Deferred,將最後一個封裝成了該對象。async可以支持併發,此時一般都跟await一起使用,看下面的例子。
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
GlobalScope.launch {
val result1 = GlobalScope.async {
getResult1()
}
val result2 = GlobalScope.async {
getResult2()
}
val result = result1.await() + result2.await()
Log.e(TAG,"result = $result")
}
}
private suspend fun getResult1(): Int {
delay(3000)
return 1
}
private suspend fun getResult2(): Int {
delay(4000)
return 2
}
async是不阻塞線程的,也就是說
getResult1
和getResult2
是同時進行的,所以獲取到result
的時間是4s,而不是7s。
應用
項目中的網絡請求框架大部分都是基於RxJava + Retrofit + Okhttp
封裝的,RxJava
可是很好的實現線程之間的切換,如果只是網絡框架中用到了RxJava
,那就是“大材小用”了,畢竟RxJava
的功能還是很強大的。Retrofit
從2.6.0開始已經支持協程了:可以定義成一個掛起函數。
interface Api {
@POST("user/login")
suspend fun login(): Call<User>
}
下面的例子是使用協程來代替RxJava實現線程切換。
1.首先定義一個請求相關的支持DSL語法的接收者。
class RetrofitCoroutineDSL<T> {
var api: (Call<Result<T>>)? = null
internal var onSuccess: ((T) -> Unit)? = null
private set
internal var onFail: ((msg: String, errorCode: Int) -> Unit)? = null
private set
internal var onComplete: (() -> Unit)? = null
private set
/**
* 獲取數據成功
* @param block (T) -> Unit
*/
fun onSuccess(block: (T) -> Unit) {
this.onSuccess = block
}
/**
* 獲取數據失敗
* @param block (msg: String, errorCode: Int) -> Unit
*/
fun onFail(block: (msg: String, errorCode: Int) -> Unit) {
this.onFail = block
}
/**
* 訪問完成
* @param block () -> Unit
*/
fun onComplete(block: () -> Unit) {
this.onComplete = block
}
internal fun clean() {
onSuccess = null
onComplete = null
onFail = null
}
}
2.然後給協程定義一個擴展方法,用於Retrofit網絡請求。
fun <T> CoroutineScope.retrofit(dsl: RetrofitCoroutineDSL<T>.() -> Unit) {
//在主線程中開啓協程
this.launch(Dispatchers.Main) {
val coroutine = RetrofitCoroutineDSL<T>().apply(dsl)
coroutine.api?.let { call ->
//async 併發執行 在IO線程中
val deferred = async(Dispatchers.IO) {
try {
call.execute() //已經在io線程中了,所以調用Retrofit的同步方法
} catch (e: ConnectException) {
coroutine.onFail?.invoke("網絡連接出錯", -1)
null
} catch (e: IOException) {
coroutine.onFail?.invoke("未知網絡錯誤", -1)
null
}
}
//當協程取消的時候,取消網絡請求
deferred.invokeOnCompletion {
if (deferred.isCancelled) {
call.cancel()
coroutine.clean()
}
}
//await 等待異步執行的結果
val response = deferred.await()
if (response == null) {
coroutine.onFail?.invoke("返回爲空", -1)
} else {
response.let {
if (response.isSuccessful) {
//訪問接口成功
if (response.body()?.status == 1) {
//判斷status 爲1 表示獲取數據成功
coroutine.onSuccess?.invoke(response.body()!!.data)
} else {
coroutine.onFail?.invoke(response.body()?.msg ?: "返回數據爲空", response.code())
}
} else {
coroutine.onFail?.invoke(response.errorBody().toString(), response.code())
}
}
}
coroutine.onComplete?.invoke()
}
}
}
在上面的代碼中,比較難理解的是下面的代碼:
val coroutine = RetrofitCoroutineDSL<T>().apply(dsl)
dsl
是帶接收者的函數字面量,接收者是RetrofitCoroutineDSL,所有先創建一個接受者對象,然後將傳入的實參dsl
賦值給該對象。還可以寫成下面的樣子:
val coroutine = RetrofitCoroutineDsl<T>()
coroutine.dsl()
上面的寫法是直接調用函數字面量。爲了方便裏面,把上述代碼翻譯成對應的Java代碼:
RetrofitCoroutineDsl<T> coroutine = new RetrofitCoroutineDsl<T>();
dsl.invoke(coroutine);
調用函數dsl
並傳入coroutine
,其實就是把dsl
賦值給coroutine
。
3.最後一步,讓BaseActivity
實現接口CoroutineScope
,這樣在頁面中的上下文就是協程下上文
open class BaseActivity : AppCompatActivity(), CoroutineScope {
private lateinit var job: Job
override val coroutineContext: CoroutineContext
get() = Dispatchers.Main + job
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
job = Job()
}
override fun onDestroy() {
super.onDestroy()
// 關閉頁面後,結束所有協程任務
job.cancel()
}
}
+
是CoroutineContext中的運算符重載,包含兩者的上下文:
//Returns a context containing elements from this context and elements from other [context].
//The elements from this context with the same key as in the other one are dropped.
public operator fun plus(context: CoroutineContext): CoroutineContext
在Activity
中可以直接調用擴展函數retrofit
來調用網絡請求:
retrofit<User> {
api = RetrofitCreater.create(Api::class.java).login()
onSuccess {
Log.e(TAG, "result = ${it?.avatar}")
}
onFailed { msg, _ ->
Log.e(TAG, "onFailed = $msg")
}
}
如果不需要處理訪問失敗的情況,可以寫成下面的樣子:
retrofit<User> {
api = RetrofitCreater.create(Api::class.java).login()
onSuccess {
Log.e(TAG, "result = ${it?.avatar}")
}
}
使用協程可以更好的控制任務的執行,並且比線程更加的節省資源,更加的高效。結合DSL的代碼風格,可以讓我們的程序更加直觀易懂、簡潔優雅。