dependencies {
   // Kotlin
   implementation "org.jetbrains.kotlin:kotlin-stdlib:1.4.32"
   // 協(xié)程核心庫(kù)
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-core:1.4.3"
   // 協(xié)程Android支持庫(kù)
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.4.3"
   // 協(xié)程Java8支持庫(kù)
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-jdk8:1.4.3"
   // lifecycle對(duì)于協(xié)程的擴(kuò)展封裝
   implementation "androidx.lifecycle:lifecycle-viewmodel-ktx:2.2.0"
   implementation "androidx.lifecycle:lifecycle-runtime-ktx:2.2.0"
   implementation "androidx.lifecycle:lifecycle-livedata-ktx:2.2.0"
}

fun foo(){}
//類型為 () -> Unit
fun foo(p: Int){}
//類型為 (Int) -> String
class Foo{
    fun bar(p0: String,p1: Long):Any{}
    
}
//那么 bar 的類型為：Foo.(String,Long) -> Any
//Foo就是bar的 receiver。也可以寫成 (Foo,String,Long) ->Any

fun foo(){} 
//引用是 ::foo
fun foo(p0: Int): String
//引用也是 ::foo

val f: () -> Unit = ::foo //編譯器會(huì)推斷出是fun foo(){} 
val g: (Int) -> String = ::foo //推斷為fun foo(p0: Int): String

class Foo{
    fun bar(p0: String,p1: Long):Any{}
}

val h: (Foo,String,Long) -> Any = Foo:bar

val foo: Foo = Foo()
val m: (String,Long) -> Any = foo:bar

val x: (Foo,String,Long) -> Any = Foo:bar
val y: Function3<Foo,String,Long,Any> = x
Foo.(String,Long) -> Any = (Foo,String,Long) ->Any = Function3<Foo,String,Long,Any>

fun yy(p: (Foo,String,Long)->Any){
	p(Foo(),"Hello",3L)//直接p()就能調(diào)用
    //p.invoke(Foo(),"Hello",3L) 也可以用invoke形式
}

//普通函數(shù)
fun func(){
   println("hello");
}
?
//去掉函數(shù)名 func,就成了匿名函數(shù)
fun(){
   println("hello");    
//可以賦值給一個(gè)變量
val func = fun(){
//匿名函數(shù)的類型
val func :()->Unit = fun(){
//Lambda表達(dá)式
val func={
   print("Hello");
//Lambda類型
val func :()->String = {
print("Hello");
"Hello" //如果是Lambda中，最后一行被當(dāng)作返回值，能省掉return。普通函數(shù)則不行
//帶參數(shù)Lambda
val f1: (Int)->Unit = {p:Int ->
print(p);
//可進(jìn)一步簡(jiǎn)化為
val f1 = {p:Int ->
print(p);    
//當(dāng)只有一個(gè)參數(shù)的時(shí)候，還可以寫成
val f1: (Int)->Unit = {
   print(it);

//com.example.studycoroutine.chapter.CoroutineRun.kt
suspend fun suspendFun(): Int {
    return 1;
}

public static final Object suspendFun(Continuation completion) {
    return Boxing.boxInt(1);
}

public fun <T> (suspend () -> T).startCoroutine(completion: Continuation<T>) {
   createCoroutineUnintercepted(completion).intercepted().resume(Unit)
}
?
public fun <T> (suspend () -> T).createCoroutine(completion: Continuation<T>): Continuation<Unit> =
   SafeContinuation(createCoroutineUnintercepted(completion).intercepted(), COROUTINE_SUSPENDED)

fun main() {
   val b = suspend {
       val a = hello2()
       a
  }
   b.createCoroutine(MyCompletionContinuation()).resume(Unit)
}
?
suspend fun hello2() = suspendCoroutine<Int> {
   thread{
       Thread.sleep(1000)
       it.resume(10086)
class MyContinuation() : Continuation<Int> {
   override val context: CoroutineContext = CoroutineName("Co-01")
   override fun resumeWith(result: Result<Int>) {
       log("MyContinuation resumeWith 結(jié)果 = ${result.getOrNull()}")

//kotlin.coroutines.intrinsics.CoroutinesIntrinsicsH.kt
@SinceKotlin("1.3")
public expect fun <T> (suspend () -> T).createCoroutineUnintercepted(completion: Continuation<T>): Continuation<Unit>

public static final void main() {
     Function1 var0 = (Function1)(new Function1((Continuation)null) {
        int label;
?
        @Nullable
        public final Object invokeSuspend(@NotNull Object $result) {
           Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
           Object var10000;
           switch(this.label) {
           case 0:
              ResultKt.throwOnFailure($result);
              this.label = 1;
              var10000 = TestSampleKt.hello2(this);
              if (var10000 == var3) {
                 return var3;
              }
              break;
           case 1:
              var10000 = $result;
           default:
              throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
          }
           int a = ((Number)var10000).intValue();
           return Boxing.boxInt(a);
        }
        @NotNull
        public final Continuation create(@NotNull Continuation completion) {
           Intrinsics.checkParameterIsNotNull(completion, "completion");
           Function1 var2 = new <anonymous constructor>(completion);
           return var2;
        public final Object invoke(Object var1) {
           return((<undefinedtype>)this.create((Continuation)var1)).invokeSuspend(Unit.INSTANCE);
    });
     boolean var1 = false;
     Continuation var7 = ContinuationKt.createCoroutine(var0, (Continuation)(newMyContinuation()));
     Unit var8 = Unit.INSTANCE;
     boolean var2 = false;
     Companion var3 = Result.Companion;
     boolean var5 = false;
     Object var6 = Result.constructor-impl(var8);
     var7.resumeWith(var6);
  }

fun main() {
   suspend {
       val a = hello2()
       a
  }.createCoroutine(MyContinuation()).resume(Unit)
}

//kotlin.coroutines.intrinsics.IntrinsicsJVM.class
@SinceKotlin("1.3")
public actual fun <T> (suspend () -> T).createCoroutineUnintercepted(
   completion: Continuation<T>
): Continuation<Unit> {
//probeCompletion還是我們傳入completion對(duì)象，在我們的Demo就是myCoroutine
   val probeCompletion = probeCoroutineCreated(completion)//probeCoroutineCreated方法點(diǎn)進(jìn)去看了，好像是debug用的.我的理解是這樣的
   //This就是這個(gè)suspend lambda。在Demo中就是myCoroutineFun
   return if (this is BaseContinuationImpl)
       create(probeCompletion)
   else
//else分支在我們demo中不會(huì)走到
     //當(dāng) [createCoroutineUnintercepted] 遇到不繼承 BaseContinuationImpl 的掛起 lambda 時(shí)，將使用此函數(shù)。
       createCoroutineFromSuspendFunction(probeCompletion) {
          (this as Function1<Continuation<T>, Any?>).invoke(it)
      }
}

@NotNull
public final Continuation create(@NotNull Continuation completion) {
Intrinsics.checkNotNullParameter(completion, "completion");
Function1 var2 = new <anonymous constructor>(completion);
return var2;
}

@NotNull
public final Continuation create(@NotNull Continuation completion) {
	Intrinsics.checkNotNullParameter(completion, "completion");
	Function1 var2 = new <anonymous constructor>(completion);
	return var2;
}

internal abstract class BaseContinuationImpl{
   fun resumeWith(result: Result<Any?>) {
          // This loop unrolls recursion in current.resumeWith(param) to make saner and shorter stack traces on resume
       var current = this
       var param = result
       while (true) {
           with(current) {
               val completion = completion!! // fail fast when trying to resume continuation without completion
               val outcome: Result<Any?> =
                   try {
                       val outcome = invokeSuspend(param)//調(diào)用狀態(tài)機(jī)
                       if (outcome === COROUTINE_SUSPENDED) return
                       Result.success(outcome)
                  } catch (exception: Throwable) {
                       Result.failure(exception)
                  }
               releaseIntercepted() // this state machine instance is terminating
               if (completion is BaseContinuationImpl) {
                   // unrolling recursion via loop
                   current = completion
                   param = outcome
              } else {
                   //最終走到這里，這個(gè)completion就是被塞的第一顆球。
                   completion.resumeWith(outcome)
                   return
              }
          }
      }
  }
}

public final Object invokeSuspend(@NotNull Object $result) {
   Object var3 = IntrinsicsKt.getCOROUTINE_SUSPENDED();
   Object var10000;
   switch(this.label) {
   case 0://第一次進(jìn)來 label = 0 
      ResultKt.throwOnFailure($result);
      // label改成1了，意味著下一次被恢復(fù)的時(shí)候會(huì)走case 1，這就是所謂的【狀態(tài)流轉(zhuǎn)】
      this.label = 1; 
      //全體目光向我看齊，我宣布個(gè)事：this is 協(xié)程體對(duì)象。
      var10000 = TestSampleKt.hello2(this);
      if (var10000 == var3) {
         return var3;
      }
      break;
   case 1:
      ResultKt.throwOnFailure($result);
      var10000 = $result;
      break;
   default:
      throw new IllegalStateException("call to 'resume' before 'invoke' with coroutine");
   }

   int a = ((Number)var10000).intValue();
   return Boxing.boxInt(a);
}

suspend fun mySuspendOne() = suspendCoroutineUninterceptedOrReturn<String> { continuation ->
    thread {
        TimeUnit.SECONDS.sleep(1)
        continuation.resume("hello world")
    }
    //因?yàn)槲覀冞@個(gè)函數(shù)沒有返回正確結(jié)果，所以必須返回一個(gè)掛起標(biāo)識(shí),否則BaseContinuationImpl會(huì)認(rèn)為完成了任務(wù)。 
    // 并且我們的線程又在運(yùn)行沒有取消，這將很多意想不到的結(jié)果
    kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED
}

suspend fun mySafeSuspendOne() = suspendCoroutine<String> { continuation ->
    thread {
        TimeUnit.SECONDS.sleep(1)
        continuation.resume("hello world")
    }
    //suspendCoroutine函數(shù)很聰明的幫我們判斷返回結(jié)果如果不是想要的對(duì)象，自動(dòng)返				
    kotlin.coroutines.intrinsics.COROUTINE_SUSPENDED
}

public suspend inline fun <T> suspendCoroutine(crossinline block: (Continuation<T>) -> Unit): T =
    suspendCoroutineUninterceptedOrReturn { c: Continuation<T> ->
    	//封裝一個(gè)代理Continuation對(duì)象
        val safe = SafeContinuation(c.intercepted())
        block(safe)
        //根據(jù)block返回結(jié)果判斷要不要返回COROUTINE_SUSPENDED
        safe.getOrThrow()
    }

//調(diào)用單參數(shù)的這個(gè)構(gòu)造方法
internal actual constructor(delegate: Continuation<T>) : this(delegate, UNDECIDED)
@Volatile
private var result: Any? = initialResult //UNDECIDED賦值給 result 
//java原子屬性更新器那一套東西
private companion object {
       @Suppress("UNCHECKED_CAST")
       @JvmStatic
       private val RESULT = AtomicReferenceFieldUpdater.newUpdater<SafeContinuation<*>, Any?>(
           SafeContinuation::class.java, Any::class.java as Class<Any?>, "result"
      )
  }
?
internal actual fun getOrThrow(): Any? {
   var result = this.result // atomic read
   if (result === UNDECIDED) { //如果UNDECIDED，那么就把result設(shè)置為COROUTINE_SUSPENDED
       if (RESULT.compareAndSet(this, UNDECIDED, COROUTINE_SUSPENDED)) returnCOROUTINE_SUSPENDED
       result = this.result // reread volatile var
   return when {
       result === RESUMED -> COROUTINE_SUSPENDED // already called continuation, indicate COROUTINE_SUSPENDED upstream
       result is Result.Failure -> throw result.exception
       else -> result // either COROUTINE_SUSPENDED or data <-這里返回白板
}
public actual override fun resumeWith(result: Result<T>) {
       while (true) { // lock-free loop
           val cur = this.result // atomic read。不理解這里的官方注釋為啥叫做原子讀。我覺得 Volatile只能保證可見性。
           when {
             //這里如果是UNDECIDED 就把 結(jié)果附上去。
               cur === UNDECIDED -> if (RESULT.compareAndSet(this, UNDECIDED, result.value)) return
             //如果是掛起狀態(tài)，就通過resumeWith回調(diào)狀態(tài)機(jī)
               cur === COROUTINE_SUSPENDED -> if (RESULT.compareAndSet(this, COROUTINE_SUSPENDED, RESUMED)){
                   delegate.resumeWith(result)
                   return
              }
               else -> throw IllegalStateException("Already resumed")
          }
      }

val safe = SafeContinuation(c.intercepted())
block(safe)
safe.getOrThrow()

{
   thread{
       Thread.sleep(1000)
       it.resume(10086)
  }
}