협정(Coroutine-경량급 라인)의 사용

일반적으로 우리가 비동기적인 조작을 필요로 할 때 모두 다중 스레드를 통해 이루어진다. 그러나 스레드의 창설과 오픈은 성능을 소모하는 조작이다. 소량의 스레드를 켜는 것은 문제가 없지만 스레드가 많으면 문제가 있고 각종 데이터 동기화 문제가 있을 수 있다.협정은 경량급의 노선으로서 이 문제들을 완벽하게 해결할 수 있다.너는 100만 개의 라인을 운전해 보았니?안 죽어. 컴퓨터 먹을게.하지만 네가 100만 개의 협업을 하는 것은 분담할 일이다.여기에는 android와kotlin 중의 사용만 말한다.
의존성 추가

// kotlin   
ext.kotlin_version = '1.3.41'

// repository 
jcenter()

//   
implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android:1.3.0-RC2'

GlobalScope.launch

fun main() {
    GlobalScope.launch {
        println("      ")
        delay(1000)
        println("     ，          ")
    }
    //           
    Thread.sleep(500)
    println("      ")
}

출력: 나는 협동 주 라인에서 탈퇴했다
runBlocking

fun main() {
    runBlocking {
        launch {
            println("    ")
            delay(1000)
            println("    ")
        }
    }
    //       runBlocking         
    Thread.sleep(500)
    println("      ")
}

출력: 협정 시작 협정 종료 메인 라인 종료
suspend

fun main() {
    runBlocking {
        println("  ")
        launch {
            test()
        }
        println("  ")
    }
}

suspend fun test() {
    delay(1000L)
    println("  suspend     ")
}

출력: 시작과 끝 나는suspend 방법으로 인쇄했다
Job

fun main() {
    runBlocking {
        println("  ")
        val job = launch {
            delay(1000L)
            println("in launch")
        }
        job.join()
        println("  ")
    }
}

출력:시작 in launch 끝
cancelAndJoin
Job.cancel은 사실상 이상을 던져서 실행을 중단합니다.

fun main() {
    runBlocking {
        println("  ")
        val job = launch {
            try {
                var i = 1
                while (isActive) {
                    print(i++)
                    delay(500L)
                }
            } finally {
                println("
    ")
            }
        }
        delay(1300L)
        job.cancelAndJoin()// cancel        ，       ，     delay     
        println("  ")
    }
}

출력: 시작 123 이상 종료 종료 종료
withTimeout Timeout실제로도 이상을 던졌다.

fun main() {
    runBlocking {
        println("  ")
        try {
            val result = withTimeout(1300) {
                repeat(10) {
                    print(it)
                    delay(500)
                }
                "    ，  Timeout"
            }
            println("
   result=$result")
        } catch (e: TimeoutCancellationException) {
            println("
   Timeout ")
        }
    }
}

출력: 012 Timeout 시작
Channel Channel는 BlockingQueue에 해당한다

fun main() {
    runBlocking {
        println("  ")
        val channel = Channel<Int>()
        launch {
            for (x in 1..5) channel.send(x * x)
            channel.close()
        }
        for (y in channel) print("$y ")
        println("
  ")
    }
}

출력: 시작 1 4 9 16 25 끝
async、await

fun main() {
    runBlocking {
        println("  ")
        val d = async {
            println("async start...")
            delay(1000)
            println("async end")
            999
        }
        println("d=${d.await()}")
        println("  ")
    }
}

async를 실행하지 않으려면 CoroutineStart.LAZY를 추가하면 됩니다. 그리고 async는 호출start 또는 await을 기다려야 실행됩니다. 다음과 같습니다.

fun main() {
    runBlocking {
        println("  ")
        val d = async(start = CoroutineStart.LAZY) {
            println("async start...")
            delay(1000)
            println("async end")
            999
        }
        d.start()
        println("d=${d.await()}")
        println("  ")
    }
}

출력: async start 시작...async end d=999 끝
실제 실행 스레드

fun main() {
    runBlocking {
        //          
        launch {
            println("launch\t\t\t\t\t" + Thread.currentThread().name)
        }

        //          
        GlobalScope.launch {
            println("GlobalScope.launch\t\t" + Thread.currentThread().name)
        }

        //          
        launch(Dispatchers.Default) {
            println("Dispatchers.Default\t\t" + Thread.currentThread().name)
        }

        //          
        launch(Dispatchers.IO) {
            println("Dispatchers.IO\t\t\t" + Thread.currentThread().name)
        }

        //     ，         ，                    
        launch(Dispatchers.Unconfined) {
            println("Dispatchers.Unconfined\t" + Thread.currentThread().name)
        }

        //   android    main
//        launch(Dispatchers.Main) {
//            println("Dispatchers.Main\t\t" + Thread.currentThread().name)
//        }
    }
}

출력: GlobalScope.launch DefaultDispatcher-worker-1 Dispatchers.Default DefaultDispatcher-worker-3 Dispatchers.IO DefaultDispatcher-worker-3 Dispatchers.Unconfined main launch main
공식 문서
https://kotlinlang.org/docs/reference/coroutines/coroutines-guide.html https://github.com/Kotlin/kotlinx.coroutines