code

CoroutineScope - launch

sinply 2025. 3. 13. 23:03
반응형
SMALL

코루틴을 만들고 실행하는 방식은 CoroutineScope에 따라 달라지는데, launch는 비동기적으로 새로운 코루틴을 실행하고 결과를 반환하지 않습니다.

🔹 launch는 새로운 코루틴을 생성하고 실행한다

 
import kotlinx.coroutines.*

fun main() = runBlocking {
    println("메인 스레드 시작: ${Thread.currentThread().name}")

    launch {
        println("새로운 코루틴 실행! (스레드: ${Thread.currentThread().name})")
    }

    println("메인 스레드 종료")
}

💡 예상 출력
메인 스레드 시작: main
메인 스레드 종료
새로운 코루틴 실행! (스레드: main)

✅ 설명

  • launch는 새로운 코루틴을 실행하지만, 비동기 실행이므로 launch를 호출한 후 바로 다음 코드(메인 스레드 종료)가 실행됨.
  • 따라서 launch 블록이 끝나기도 전에 runBlocking이 종료되면 코루틴이 실행되지 않을 수도 있음.

🔹 launch를 호출할 때마다 새로운 코루틴이 생성됨

 
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch { println("첫 번째 코루틴! (스레드: ${Thread.currentThread().name})") }
    launch { println("두 번째 코루틴! (스레드: ${Thread.currentThread().name})") }
    launch { println("세 번째 코루틴! (스레드: ${Thread.currentThread().name})") }
}

💡 예상 출력
첫 번째 코루틴! (스레드: main)
두 번째 코루틴! (스레드: main)
세 번째 코루틴! (스레드: main)

✅ 설명

  • launch를 호출할 때마다 독립적인 코루틴이 생성되어 실행됨.
  • 현재는 runBlocking 내부에서 실행되므로 기본적으로 main 스레드에서 실행됨.

🔹 launch를 사용할 때 스레드 변경 (Dispatchers 사용)

launch는 새로운 코루틴을 실행할 때 어떤 디스패처를 사용할지 지정 가능합니다.

 
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch(Dispatchers.IO) {
        println("IO 디스패처에서 실행! (스레드: ${Thread.currentThread().name})")
    }
    
    launch(Dispatchers.Default) {
        println("Default 디스패처에서 실행! (스레드: ${Thread.currentThread().name})")
    }

    launch(Dispatchers.Main) { // ⚠️ JVM에서는 에러 발생 가능 (Android 환경에서 실행해야 함)
        println("Main 디스패처에서 실행! (스레드: ${Thread.currentThread().name})")
    }
}

💡 예상 출력 (환경에 따라 다를 수 있음)
IO 디스패처에서 실행! (스레드: DefaultDispatcher-worker-1)
Default 디스패처에서 실행! (스레드: DefaultDispatcher-worker-2)

✅ 설명

  • Dispatchers.IO → 입출력(IO) 작업을 최적화한 백그라운드 스레드에서 실행
  • Dispatchers.Default → CPU 연산에 최적화된 스레드 풀에서 실행
  • Dispatchers.Main → 메인(UI) 스레드에서 실행 (Android에서만 사용 가능)

🔹 launch는 비동기 실행이므로 종료를 기다리지 않음

 
import kotlinx.coroutines.*

fun main() = runBlocking {
    launch {
        delay(1000)
        println("코루틴 완료!")
    }
    println("메인 블록 끝!")
}

💡 예상 출력
메인 블록 끝!
(1초 후)
코루틴 완료!

✅ 설명

  • launch는 비동기 실행되므로 delay(1000)을 만나도 runBlocking 블록의 끝까지 실행된 후 종료됨.
  • 따라서 "메인 블록 끝!"이 먼저 출력된 후, 1초 뒤 "코루틴 완료!"가 출력됨.

🔹 launch는 새로운 코루틴을 생성하지만, 부모 코루틴이 취소되면 자식 코루틴도 취소됨

 
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        repeat(10) {
            println("작업 진행 중... $it")
            delay(500)
        }
    }

    delay(1500) // 1.5초 후
    job.cancel() // 코루틴 취소
    println("코루틴 취소됨!")
}

💡 예상 출력
작업 진행 중... 0
작업 진행 중... 1
작업 진행 중... 2
코루틴 취소됨!

 

✅ 설명

  • launch를 이용해 실행된 코루틴은 부모(runBlocking)가 취소되면 자식 코루틴도 자동으로 취소됨
  • job.cancel()을 호출하면 실행 중이던 코루틴이 종료됨

📌 정리

✔ launch를 호출하면 새로운 코루틴이 생성되고 실행됨
✔ launch는 비동기 실행이므로 결과를 반환하지 않음
✔ launch를 호출할 때마다 새로운 코루틴이 독립적으로 실행됨
✔ Dispatchers.IO, Dispatchers.Default 등을 사용하면 스레드를 변경할 수 있음
✔ 부모 코루틴이 종료되거나 취소되면 자식 코루틴도 취소됨

LIST