Coroutine context and dispatchers

launch { // 부모 컨텍스트, main runBlocking 코루틴의 컨텍스트 println("main runBlocking : I'm working in thread ${Thread.currentThread().name}") } launch(Dispatchers.Unconfined) { // 구속되지 않음 -- main 스레드에서 실행 println("Unconfined : I'm working in thread ${Thread.currentThread().name}") } launch(Dispatchers.Default) { // DefaultDispatcher로 전달됨 println("Default : I'm working in thread ${Thread.currentThread().name}") } launch(newSingleThreadContext("MyOwnThread")) { // 새 스레드에서 실행 println("newSingleThreadContext: I'm working in thread ${Thread.currentThread().name}") } // 출력: (순서가 달라질 수 있음) // Unconfined : I'm working in thread main // Default : I'm working in thread DefaultDispatcher-worker-1 // newSingleThreadContext: I'm working in thread MyOwnThread // main runBlocking : I'm working in thread main

launch(Dispatchers.Unconfined) { // 구속되지 않음 -- 메인 스레드에서 실행 println("Unconfined : I'm working in thread ${Thread.currentThread().name}") delay(500) println("Unconfined : After delay in thread ${Thread.currentThread().name}") } launch { // 부모 컨텍스트, main runBlocking 코루틴의 컨텍스트 println("main runBlocking: I'm working in thread ${Thread.currentThread().name}") delay(1000) println("main runBlocking: After delay in thread ${Thread.currentThread().name}") } // 출력: // Unconfined : I'm working in thread main // main runBlocking: I'm working in thread main // Unconfined : After delay in thread kotlinx.coroutines.DefaultExecutor // main runBlocking: After delay in thread main

val a = async { log("I'm computing a piece of the answer") 6 } val b = async { log("I'm computing another piece of the answer") 7 } log("The answer is ${a.await() * b.await()}") // 출력: // [main @coroutine#2] I'm computing a piece of the answer // [main @coroutine#3] I'm computing another piece of the answer // [main @coroutine#1] The answer is 42

import kotlinx.coroutines.* fun log(msg: String) = println("[${Thread.currentThread().name}] $msg") fun main() { newSingleThreadContext("Ctx1").use { ctx1 -> newSingleThreadContext("Ctx2").use { ctx2 -> runBlocking(ctx1) { log("Started in ctx1") withContext(ctx2) { log("Working in ctx2") } log("Back to ctx1") } } } } // 출력: (디버깅 모드로) // [Ctx1 @coroutine#1] Started in ctx1 // [Ctx2 @coroutine#1] Working in ctx2 // [Ctx1 @coroutine#1] Back to ctx1

println("My job is ${coroutineContext[Job]}") // 출력: // My job is "coroutine#1":BlockingCoroutine{Active}@6d311334

// 어떤 요청을 처리하기 위해 코루틴을 시작 val request = launch { // 두 개의 다른 작업을 생성함 launch(Job()) { println("job1: 나는 내 자신의 Job에서 실행되고 독립적으로 실행돼!") delay(1000) println("job1: 나는 요청이 취소되어도 영향을 받지 않아") } // 다른 하나는 부모 컨텍스트를 상속받음 launch { delay(100) println("job2: 나는 요청 코루틴의 자식이야") delay(1000) println("job2: 부모 요청이 취소되면 나는 이 줄을 실행하지 않을 거야") } } delay(500) request.cancel() // 요청 처리 취소 println("main: 요청 취소 후 누가 살아남았을까?") delay(1000) // 무슨 일이 일어나는지 확인하기 위해 메인 스레드를 1초간 지연 // 출력: // job1: 나는 내 자신의 Job에서 실행되고 독립적으로 실행돼! // job2: 나는 요청 코루틴의 자식이야 // main: 요청 취소 후 누가 살아남았을까? // job1: 나는 요청이 취소되어도 영향을 받지 않아

// 어떤 요청을 처리하기 위해 코루틴을 시작 val request = launch { repeat(3) { i -> // 여러 자식 작업을 시작 launch { delay((i + 1) * 200L) // 200ms, 400ms, 600ms의 가변 지연 시간 println("Coroutine $i is done") } } println("request: 나는 끝났고, 여전히 활동 중인 자식들을 명시적으로 join하지 않아도 돼") } request.join() // 요청과 그 자식들이 완료될 때까지 기다림 println("이제 요청 처리가 완료되었습니다") // 출력: // request: 나는 끝났고, 여전히 활동 중인 자식들을 명시적으로 join하지 않아도 돼 // Coroutine 0 is done // Coroutine 1 is done // Coroutine 2 is done // 이제 요청 처리가 완료되었습니다

log("Started main coroutine") // 두 개의 백그라운드 값 계산 실행 val v1 = async(CoroutineName("v1coroutine")) { delay(500) log("Computing v1") 6 } val v2 = async(CoroutineName("v2coroutine")) { delay(1000) log("Computing v2") 7 } log("The answer for v1 * v2 = ${v1.await() * v2.await()}") // 출력: // [main @main#1] Started main coroutine // [main @v1coroutine#2] Computing v1 // [main @v2coroutine#3] Computing v2 // [main @main#1] The answer for v1 * v2 = 42

launch(Dispatchers.Default + CoroutineName("test")) { println("I'm working in thread ${Thread.currentThread().name}") } // 출력: // I'm working in thread DefaultDispatcher-worker-1 @test#2

class Activity { private val mainScope = MainScope() fun destroy() { mainScope.cancel() } // 계속 ...

// class Activity 계속 fun doSomething() { // 데모를 위해 10개의 코루틴 실행, 각각 다른 시간 동안 작업 수행 repeat(10) { i -> mainScope.launch { delay((i + 1) * 200L) // 가변 딜레이: 200ms, 400ms, ... 등 println("Coroutine $i is done") } } } } // class Activity 끝

val activity = Activity() activity.doSomething() // 테스트 함수 실행 println("Launched coroutines") delay(500L) // 반초 대기 println("Destroying activity!") activity.destroy() // 모든 코루틴 취소 delay(1000) // 더 이상 동작하지 않는 것을 시각적으로 확인 // 출력: // Launched coroutines // Coroutine 0 is done // Coroutine 1 is done // Destroying activity!

threadLocal.set("main") println("Pre-main, current thread: ${Thread.currentThread()}, thread local value: '${threadLocal.get()}'") val job = launch(Dispatchers.Default + threadLocal.asContextElement(value = "launch")) { println("Launch start, current thread: ${Thread.currentThread()}, thread local value: '${threadLocal.get()}'") yield() println("After yield, current thread: ${Thread.currentThread()}, thread local value: '${threadLocal.get()}'") } job.join() println("Post-main, current thread: ${Thread.currentThread()}, thread local value: '${threadLocal.get()}'") // 출력: // Pre-main, current thread: Thread[main @coroutine#1,5,main], thread local value: 'main' // Launch start, current thread: Thread[DefaultDispatcher-worker-1 @coroutine#2,5,main], thread local value: 'launch' // After yield, current thread: Thread[DefaultDispatcher-worker-2 @coroutine#2,5,main], thread local value: 'launch' // Post-main, current thread: Thread[main @coroutine#1,5,main], thread local value: 'main'