前言

        為什么在kotlin要使用協(xié)程呢，這好比去了重慶不吃火鍋一樣的道理。協(xié)程的概念并不陌生，在python也有提及。任何事務(wù)的作用大多是對于所依賴的環(huán)境相應(yīng)而生的，協(xié)程對于kotlin這門語言也不例外。協(xié)程的優(yōu)點，總的來說有如下幾點：輕量級，占用更少的系統(tǒng)資源； 更高的執(zhí)行效率； 掛起函數(shù)較于實現(xiàn)Runnable或Callable接口更加方便可控； kotlin.coroutine 核心庫的支持，讓編寫異步代碼更加簡單。當(dāng)然在一些不適應(yīng)它的用法下以上優(yōu)勢也會成為劣勢。

1.協(xié)程定義

協(xié)程定義:kotlin官方基于JVM的線程實現(xiàn)的一個并發(fā)任務(wù)處理框架，封裝的線程api

1. 使用方便，不使用回調(diào)實現(xiàn)線程切換,使用同步方式寫出異步代碼
2. 所有的耗時任務(wù)保證一定放在后臺執(zhí)行掛起
3. 函數(shù)執(zhí)行完畢之后，協(xié)程會把它切換到原先的線程的線程。

2.協(xié)程的基本用法

常規(guī)函數(shù)中一般都有：call and return,協(xié)程在此之外添加了suspend和resume.

1. suspend 用于暫停執(zhí)行的當(dāng)前協(xié)程,并保存所有的局部變量
2. resume 用于已暫停的協(xié)程中暫停出恢復(fù)

supend(掛起函數(shù))是什么，有什么意義

suspend，對協(xié)程的掛起并沒有實際作用，其實只是一個提醒，函數(shù)創(chuàng)建者對函數(shù)的調(diào)用者的提醒，提醒調(diào)用者我是需要耗時操作，需要用掛起的方式,在協(xié)程中使用.

1. 需要注意的是掛起函數(shù)只能在掛起函數(shù)或者協(xié)程作用域中使用，為什么掛起函數(shù)需要在協(xié)程作用域中使用？因為普通函數(shù)沒有suspend和resume這兩個特性，所以必須要在協(xié)程的作用中使用。
2. 意義：
3. 語法層面：作為一個標記和提醒。通過報錯來提醒調(diào)用者和編譯器，這是一個耗時函數(shù)，需要放在后臺執(zhí)行。
4. 編譯器層面：輔助 Kotlin 編譯器來把代碼轉(zhuǎn)換成 JVM 的字節(jié)碼。
5. 怎么自定義suspend函數(shù)？
6. 什么時候定義？
7. 需要耗時操作的時候,需要定義,例如io耗時操作(請求網(wǎng)絡(luò))；獲取數(shù)據(jù)庫數(shù)據(jù)；一些等待一會需要的操作；列表排除，json解析等;
8. 怎么寫suspend函數(shù)，給函數(shù)前加上suspend 關(guān)鍵字，把內(nèi)容用withContext包起來

suspend fun testSuspendfun(){
      withContext(Dispatchers.IO){
 
      }
  }

協(xié)程如何確保主線程安全

1. Dispatchers.Main 調(diào)用程序在Android的主線程中
2. Dispatchers.IO 適合主線程之外的執(zhí)行磁盤或者網(wǎng)絡(luò)io操作，例如文件的讀取與寫入，任何的網(wǎng)絡(luò)請求
3. Dispatcher.Default 適合主線程之外的，cpu的操作，例如json數(shù)據(jù)的解析，以及列表的排序，

協(xié)程的掛起本質(zhì)：本質(zhì)就是切線程，完成之后只不過可以自動切回來

協(xié)程掛起就是切個線程，在掛起函數(shù)執(zhí)行完畢之后，協(xié)程會自動的重新切回它原先的線程，也就是稍后會被切回來的線程切換。切回來就是resume，恢復(fù)功能是協(xié)程，所以suspend函數(shù)需要在另一個suspend函數(shù)或者協(xié)程中調(diào)用。「非阻塞式掛起」阻塞的方式寫出了非阻塞的方式。

3.協(xié)程的創(chuàng)建以及取消

//創(chuàng)建一個協(xié)程
 
Val scope = CoroutineScope(Dispatchers.Main+Job())
 
通過Job獲取協(xié)程的生命周期
 
scope.launch{
}
 
其他耗時請求，例如從數(shù)據(jù)庫中獲取數(shù)據(jù)
 
 scope.async {
 }

在KTX庫為某些生命周期提供自己的CoroutineScope，例如ViewModel中viewModelScope，Lifecycle有l(wèi)ifecycleScope

協(xié)程的啟動，launch 啟動新協(xié)程而不將結(jié)果返回給調(diào)用方

//創(chuàng)建之后，不管后續(xù)
launch(){
}

async 啟動一個新協(xié)程，并通過deferred的await方法暫停函數(shù)

//返回deferred 對象
val deferred async{
 
}
deferred.await()

協(xié)程的結(jié)構(gòu)化并發(fā)，取消協(xié)程

協(xié)程的結(jié)構(gòu)化并發(fā)，可以讓協(xié)程非常便于管理。例如在關(guān)閉activity中要取消協(xié)程。如果是在線程中，取消所有的線程比較復(fù)雜。

取消父協(xié)程以及父里面的子協(xié)程

  val scope = CoroutineScope(Dispatchers.Main+ Job())
        scope.launch {
            val job = launch {
 
               val job1 =  launch {
                   
                }
            }
            job.cancel()
        }
        scope.cancel()

取消子協(xié)程某一個，每一個協(xié)程都會返回一個job對象，通過調(diào)用job的cancle，可以去取消單個的協(xié)程的。

val scope = CoroutineScope(Dispatchers.Main+ Job())
        scope.launch {
            val job = launch {
 
               val job1 =  launch {
                   
                }
            }
            job.cancel()
        }
        scope.cancel()

4.協(xié)程中異常處理

  在協(xié)程內(nèi)部中捕獲異常

val scope = CoroutineScope(Dispatchers.Main+ Job())
        scope.launch {
            try {
                
            }catch (e:Exception){
            }
        }

5.協(xié)程的優(yōu)勢

        在程序運行過程中某些操作（像是：網(wǎng)絡(luò)IO、文件IO、CPU或GUP計算密集型工作等等）可能會耗費大量的時間，在單線程的環(huán)境下可能會造成線程的阻塞，在他們完成之前沒辦去做其它事情。使用傳統(tǒng)方法的話，我們可能會選擇使用多線程來解決這個問題，將這些耗時操作放置到新的線程中去執(zhí)行，使主線程能夠正常的運行。那么本文標題所提到的協(xié)程是怎么一回事呢？

        協(xié)程可以看作是一個輕量級的線程，他不是由操作系統(tǒng)或是虛擬機來實現(xiàn)的，而是通過編譯器。這意味著相對于線程，協(xié)程的開銷更小。大家可以從下面的這個例子中感受一下。

        下面是一段Kotlin使用協(xié)程的代碼，創(chuàng)建了100萬個協(xié)程 (官方的例子是使用的100K，不過運行時間太短，不好截內(nèi)存的使用情況）。

fun main(args: Array)= runBlocking {    val jobs= List(1_000_000){
        launch(CommonPool){
            delay(10L)
            println(it)
       }
    }
    jobs.forEach { it.join() }
}

內(nèi)存使用情況

運行耗時：

然后是使用線程來進行實現(xiàn)的代碼：

fun main(args: Array) {    val threadList=List(1_000_000){
        Thread{
            Thread.sleep(10L)
            println(it)
        }
    }
    threadList.forEach { it.start();it.join() }
}

內(nèi)存使用情況：

運行耗時：10分鐘以上。

        使用線程的代碼，占用的內(nèi)存幾乎是使用協(xié)程的兩倍。而且從運行時間上看使用協(xié)程實現(xiàn)的程序話費的時間要遠遠低于線程的實現(xiàn)方式。單從這兩點來看，協(xié)程擁有更高的執(zhí)行效率，占用更少的系統(tǒng)資源。那么Kotlin中的協(xié)程是通過什么來實現(xiàn)異步操作的呢？它使用的是一種叫做 掛起 的機制。協(xié)程的掛起幾乎是沒有損耗的，換種說法，就是不需要選擇額外的上下文或是操作系統(tǒng)調(diào)用。 另外一點, 掛起能很大程度上被用戶庫給控制：我們可以決定在掛起狀態(tài)下具體做些什么，并且圍繞著需求進行優(yōu)化／日志／攔截等操作。

        協(xié)程不能隨隨便便就被掛起，只能在一個稱為掛起點的地方，在這里會去調(diào)用特別標記的函數(shù)。這樣的函數(shù)被稱作 掛起函數(shù)，因為你調(diào)用他們會掛起一個協(xié)程（如果允許這次調(diào)用的話，庫可以直接進行處理而不需要掛起）。 掛起函數(shù)的聲明需要添加suspend修飾符。例如：

suspend fun doSomething(foo: Foo): Bar {
...
}

        掛起函數(shù)就像平常使用的函數(shù)一樣，可以有參數(shù)和返回值，但是他們只能被協(xié)程或是其它掛起函數(shù)調(diào)用。事實上，要想啟動一個協(xié)程，至少得有一個掛起函數(shù)，并且一般是匿名的（也就是一個掛起lambda表達式）。

        線程往往是沒有返回值（實現(xiàn)Runnable接口），盡管可以通過實現(xiàn)Callable接口來獲得帶返回值的線程。但這與協(xié)程在語法層面上的支持，在使用的便捷性上還是有不少差距的。

        協(xié)程是通過編譯技術(shù)實現(xiàn)的 (不需要虛擬機或操作系統(tǒng)的特別支持)，這一點在開頭也提到了。掛起操作通過代碼變換實現(xiàn)?；旧希恳粋€掛起函數(shù)（可能會進行優(yōu)化，但我們在著不想討論這點）都被轉(zhuǎn)換成一個狀態(tài)機，那些狀態(tài)與掛起調(diào)用相對應(yīng)。在一個掛起準備好之前，下一狀態(tài)與相關(guān)局部變量等一起存儲在編譯器生成的類的字段中。在恢復(fù)該協(xié)程時，恢復(fù)局部變量并且狀態(tài)機從剛好掛起之后的狀態(tài)進行。掛起的協(xié)程可以作為保持其掛起狀態(tài)與局部變量的對象來存儲和傳遞。

        許多其它語言實現(xiàn)的異步機制也能制作成庫，在Kotlin的協(xié)程中使用。包括：C#和ECMAScript寫的 async/await ， channels Go語言寫的 select ；C#和Python寫的 generators/yield 。

到此這篇關(guān)于kotlin之協(xié)程的理解與使用詳解的文章就介紹到這了,更多相關(guān)kotlin之協(xié)程內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論