코루틴 기초 — suspend, launch, async의 동작 원리

// 10만 개의 코루틴을 만들어도 문제없음
fun main() = runBlocking {
    repeat(100_000) {
        launch {
            delay(1000L)
            print(".")
        }
    }
}
// 같은 걸 스레드로 하면? OutOfMemoryError

suspend fun fetchUser(): User {
    // 네트워크 요청 동안 코루틴이 중단됨
    // 이 사이에 스레드는 다른 코루틴을 실행할 수 있음
    return apiService.getUser()
}

// 우리가 작성하는 코드
suspend fun fetchUser(): User

// 컴파일러가 변환한 코드 (개념적)
fun fetchUser(continuation: Continuation<User>): Any?

// 코루틴 또는 다른 suspend 함수에서만 호출 가능
suspend fun loadData() {
    val user = fetchUser()  // OK — suspend 함수에서 호출
}

fun main() {
    // fetchUser()  // 컴파일 에러! 일반 함수에서 호출 불가
    runBlocking {
        fetchUser()  // OK — 코루틴 빌더 안에서 호출
    }
}

class MyViewModel : ViewModel() {
    // viewModelScope: ViewModel이 소멸되면 모든 코루틴 자동 취소
    fun loadData() {
        viewModelScope.launch {
            val data = repository.fetchData()
            _state.value = data
        }
    }
}

suspend fun loadAllData() = coroutineScope {
    val users = async { fetchUsers() }
    val posts = async { fetchPosts() }
    // 둘 다 끝나야 coroutineScope가 반환됨
    combineData(users.await(), posts.await())
}

val job: Job = scope.launch {
    // 결과를 반환하지 않음
    saveToDatabase(data)
    sendNotification()
}

// 필요하면 취소하거나 완료를 기다릴 수 있음
job.cancel()
job.join()  // 완료될 때까지 대기

val deferred: Deferred<User> = scope.async {
    // 결과를 반환함
    fetchUser(userId)
}

val user: User = deferred.await()  // 결과를 기다림

// 순차 실행 — 총 2초
suspend fun sequential() {
    val user = fetchUser()       // 1초
    val posts = fetchPosts()     // 1초
}

// 병렬 실행 — 총 1초
suspend fun parallel() = coroutineScope {
    val user = async { fetchUser() }     // 동시에 시작
    val posts = async { fetchPosts() }   // 동시에 시작
    println("${user.await()}, ${posts.await()}")
}

scope.launch(Dispatchers.IO) {
    // I/O 작업
    val data = readFile("data.json")

    withContext(Dispatchers.Main) {
        // UI 업데이트
        textView.text = data
    }
}

// 잘못된 예: I/O 작업을 메인 스레드에서 실행
scope.launch(Dispatchers.Main) {
    val data = readFile("data.json")  // 메인 스레드 블로킹!
}

// 올바른 예: withContext로 I/O 디스패처 전환
scope.launch(Dispatchers.Main) {
    val data = withContext(Dispatchers.IO) {
        readFile("data.json")
    }
    textView.text = data  // 다시 메인 스레드
}

val job = launch {
    repeat(1000) { i ->
        println("작업 중: $i")
        delay(100)  // delay는 취소 가능한 suspend 함수
    }
}

delay(500)
job.cancel()  // 취소 요청
job.join()    // 취소 완료 대기 (cancelAndJoin()으로 합칠 수 있음)

val job = launch {
    var i = 0
    while (isActive) {  // isActive로 취소 여부 확인
        i++
        // CPU 집약적 작업
    }
}