一文彻底搞懂Kotlin中的协程

//传统回调方式
api.login(phone,psd).enquene(new Callback<User>(){
 public void onSuccess(User user){
 api.submitAddress(address).enquene(new Callback<Result>(){
 public void onSuccess(Result result){
 ...
 }
 });
 }
});

//使用协程后
val user=api.login(phone,psd)
api.submitAddress(address)
...

val job = GlobalScope.launch {
 delay(1000)
 println("World World!")
}

public suspend fun delay(timeMillis: Long) {
 ...
}

implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:$coroutines_version"

implementation 'androidx.activity:activity-ktx:$lifecycle_scope_version'

implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:$coroutines_viewmodel_version"

lifecycleScope.launch { 
 delay(2000)
 tvTest.text="Test"
}

lifecycleScope.launch {
 val text=getText()
 tvTest.text = text
}

suspend fun getText():String{
 delay(2000)
 return "getText"
}

suspend fun getTextInOtherThread() = suspendCancellableCoroutine<String> {
 thread {
 Thread.sleep(2000)
 it.resume("getText")
 }
}

lifecycleScope.launch {
 try {
 val text=getText()
 tvTest.text = text
 } catch (e:Exception){
 e.printStackTrace()
 }
}

val job = lifecycleScope.launch {
 try {
 val text=getText()
 tvTest.text = text
 } catch (e:Exception){
 e.printStackTrace()
 }
}
lifecycleScope.launch {
 delay(1000)
 job.cancel()
}

lifecycleScope.launch {
 try {
 withTimeout(1000) {
  val text = getText()
  tvTest.text = text
 }
 } catch (e:Exception){
 e.printStackTrace()
 }
}

lifecycleScope.launch {
 val one= async {
 delay(1000)
 return@async 1
 }
 val two= async {
 delay(2000)
 return@async 2
 }
 Log.i("scope test",(one.await() two.await()).toString())
}

public interface CoroutineScope {
 public val coroutineContext: CoroutineContext
}

class TestScope() : CoroutineScope {
 override val coroutineContext: CoroutineContext
  get() = TODO("Not yet implemented")
}

/**
 * Persistent context for the coroutine. It is an indexed set of [Element] instances.
 * An indexed set is a mix between a set and a map.
 * Every element in this set has a unique [Key].
 */
public interface CoroutineContext {
 public operator fun <E : Element> get(key: Key<E>): E?
 public fun <R> fold(initial: R, operation: (R, Element) -> R): R
 public operator fun plus(context: CoroutineContext): CoroutineContext = 
  ...
 public fun minusKey(key: Key<*>): CoroutineContext
 
 public interface Key<E : Element>
 public interface Element : CoroutineContext {
  ...
 }
}

class TestScope() : CoroutineScope {
 override val coroutineContext: CoroutineContext
  get() = SupervisorJob()  Dispatchers.Main
}

val testScope=TestScope()

override fun onDestroy() {
 testScope.cancel()
 super.onDestroy()
}

testScope.launch{
 val text = getText()
 tvTest.text = text
}

val job2= lifecycleScope.launch(start = CoroutineStart.LAZY) {
 delay(2000)
 Log.i("scope test","lazy")
}
job2.start()

val job1= GlobleScope.launch(start = CoroutineStart.LAZY) {
 delay(2000)
 Log.i("scope test","job1")
}
lifecycleScope.launch {
 job1.join()
 delay(2000)
 Log.i("scope test","job2")
}

suspend fun test1(){}
fun test2(){}

public final Object test1(@NotNull Continuation $completion) {
 return Unit.INSTANCE;
}
public final void test2() {
}

public final test1(Lkotlin/coroutines/Continuation;)Ljava/lang/Object;
 ...
 L0
 LINENUMBER 6 L0
 GETSTATIC kotlin/Unit.INSTANCE : Lkotlin/Unit;
 ARETURN
 L1
 LOCALVARIABLE this Lcom/lieni/android_c/ui/test/TestActivity; L0 L1 0
 LOCALVARIABLE $completion Lkotlin/coroutines/Continuation; L0 L1 1
 MAXSTACK = 1
 MAXLOCALS = 2

public final test2()V
 L0
 LINENUMBER 9 L0
 RETURN
 L1
 LOCALVARIABLE this Lcom/lieni/android_c/ui/test/TestActivity; L0 L1 0
 MAXSTACK = 0
 MAXLOCALS = 1

public interface Continuation<in T> {
  public val context: CoroutineContext
  public fun resumeWith(result: Result<T>)
}

internal abstract class BaseContinuationImpl(...) : Continuation<Any?>, CoroutineStackFrame, Serializable {
  public final override fun resumeWith(result: Result<Any?>) {
    ...
    while (true) {
      ...
      with(current) {
       	val outcome = invokeSuspend(param)
        ...
        releaseIntercepted() 
        if (completion is BaseContinuationImpl) {
          ...
        } else {
          ...
          return
        }
      }
    }
  }
  ...
}

internal abstract class ContinuationImpl(...) : BaseContinuationImpl(completion) {
  ...
  protected override fun releaseIntercepted() {
    val intercepted = intercepted
    if (intercepted != null && intercepted !== this) {
      context[ContinuationInterceptor]!!.releaseInterceptedContinuation(intercepted)
    }
    this.intercepted = CompletedContinuation 
  }
}

public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T =
  suspendCoroutineUninterceptedOrReturn { c: Continuation<T> ->
    val safe = SafeContinuation(c.intercepted())
    ...
  }

internal abstract class ContinuationImpl(...) : BaseContinuationImpl(completion) {
  ...
  public fun intercepted(): Continuation<Any?> =intercepted
      ?: (context[ContinuationInterceptor]?.interceptContinuation(this) ?: this)
        .also { intercepted = it }
}

runBlocking { 
  delay(2000)
  Log.i("scope test","runBlocking is completed")
}

public fun <T> runBlocking(...): T {
  ...
  val coroutine = BlockingCoroutine<T>(newContext, currentThread, eventLoop)
  coroutine.start(CoroutineStart.DEFAULT, coroutine, block)
  return coroutine.joinBlocking()
}

private class BlockingCoroutine<T>(...) : AbstractCoroutine<T>(parentContext, true) {
  ...
  fun joinBlocking(): T {
   ...
   while (true) {
    ...
    if (isCompleted) break
    ...
   }  
   ...
  }
}