Kotlin CoroutineScope - Coroutine Lifecycle 관리

val scope = CoroutineScope(Dispatchers.IO + Job())

scope.launch {
    // 이 coroutine은 scope에 종속됨
    val data = fetchData()
    processData(data)
}

// scope 취소 시 내부 coroutine도 모두 취소
scope.cancel()

val scope = CoroutineScope(
    Job() +
    Dispatchers.Default +
    CoroutineName("MyScope") +
    CoroutineExceptionHandler { _, e -> println("Error: $e") }
)

suspend fun fetchAllData() = coroutineScope {
    val users = async { fetchUsers() }      // 자식 1
    val products = async { fetchProducts() } // 자식 2

    // coroutineScope는 모든 자식이 완료될 때까지 대기
    Result(users.await(), products.await())
}

// 비구조적 (권장하지 않음)
fun loadData() {
    GlobalScope.launch {
        // 호출자와 무관하게 실행됨
        // 취소되지 않아 memory leak 가능성
        val data = fetchData()
    }
}

// 구조적 (권장)
suspend fun loadData() = coroutineScope {
    launch {
        // 부모 scope에 종속
        // 부모 취소 시 함께 취소
        val data = fetchData()
    }
}

suspend fun fetchUserWithDetails(userId: Long): UserDetails {
    return coroutineScope {
        val user = async { userApi.getUser(userId) }
        val friends = async { userApi.getFriends(userId) }
        val posts = async { postApi.getPostsByUser(userId) }

        UserDetails(
            user = user.await(),
            friends = friends.await(),
            posts = posts.await()
        )
    }
}

suspend fun fetchData() = coroutineScope {
    val data1 = async { api.getData1() }
    val data2 = async { throw RuntimeException("Error!") }  // 실패

    // data2의 실패로 data1도 취소됨
    // RuntimeException이 rethrow됨
    data1.await() + data2.await()
}

// 호출자에서 예외 처리
suspend fun safelyFetchData(): Result {
    return try {
        fetchData()
    } catch (e: RuntimeException) {
        Result.failure(e)
    }
}

suspend fun fetchMultipleData() = supervisorScope {
    val users = async { userApi.getUsers() }
    val products = async { productApi.getProducts() }  // 실패해도
    val orders = async { orderApi.getOrders() }        // 계속 실행

    // 각각 개별 처리
    val userResult = runCatching { users.await() }
    val productResult = runCatching { products.await() }
    val orderResult = runCatching { orders.await() }

    CombinedResult(userResult, productResult, orderResult)
}

// 권장하지 않음
fun badExample() {
    GlobalScope.launch {
        // application 전체 lifecycle
        // 취소 관리가 어려움
        performLongRunningTask()
    }
}

class MyActivity : AppCompatActivity() {
    // 나쁜 예
    fun loadDataBad() {
        GlobalScope.launch {
            // Activity 종료 후에도 계속 실행
            val data = fetchData()
            textView.text = data  // crash 가능성
        }
    }

    // 좋은 예
    fun loadDataGood() {
        lifecycleScope.launch {
            // Activity lifecycle에 종속
            val data = fetchData()
            textView.text = data
        }
    }
}

object Analytics {
    private val scope = CoroutineScope(
        SupervisorJob() + Dispatchers.IO
    )

    // GlobalScope 대신 명시적인 scope 사용 권장
    fun trackEvent(event: Event) {
        scope.launch {
            api.sendEvent(event)
        }
    }
}

class UserRepository {
    private val scope = CoroutineScope(
        Job() + Dispatchers.IO + CoroutineName("UserRepo")
    )

    fun fetchUsers() {
        scope.launch {
            val users = api.getUsers()
            cache.save(users)
        }
    }

    fun clear() {
        scope.cancel()  // 모든 coroutine 취소
    }
}

class DataSyncService {
    private val scope = CoroutineScope(
        SupervisorJob() + Dispatchers.IO
    )

    fun syncAll() {
        scope.launch { syncUsers() }     // 실패해도
        scope.launch { syncProducts() }  // 다른 작업 계속
        scope.launch { syncOrders() }
    }

    fun stop() {
        scope.cancel()
    }
}

class UserViewModel : ViewModel() {
    // viewModelScope는 ViewModel에서 제공
    fun loadUser(userId: Long) {
        viewModelScope.launch {
            val user = repository.getUser(userId)
            _userState.value = user
        }
    }
}

val parentJob = scope.launch {
    // parentJob의 자식
    val childJob1 = launch { task1() }
    val childJob2 = launch { task2() }

    println(coroutineContext[Job]?.children?.count())  // 2
}

val scope = CoroutineScope(Job())

scope.launch {
    // 독립적인 Job 생성 (부모와 무관)
    launch(Job()) {
        // 부모가 취소되어도 계속 실행
        delay(10000)
        println("Independent job")
    }
}

scope.cancel()  // 위 coroutine은 취소되지 않음

class UserRepository(
    private val api: UserApi,
    private val cache: UserCache,
    dispatcher: CoroutineDispatcher = Dispatchers.IO
) {
    private val scope = CoroutineScope(SupervisorJob() + dispatcher)

    suspend fun getUser(id: Long): User {
        return cache.get(id) ?: api.fetchUser(id).also {
            scope.launch { cache.save(it) }  // 비동기 cache 저장
        }
    }

    fun prefetch(ids: List<Long>) {
        ids.forEach { id ->
            scope.launch {
                runCatching { api.fetchUser(id) }
                    .onSuccess { cache.save(it) }
            }
        }
    }

    fun clear() {
        scope.cancel()
    }
}

suspend fun fetchDashboard(): Dashboard = supervisorScope {
    val userDeferred = async { userApi.getCurrentUser() }
    val notificationsDeferred = async { notificationApi.getUnread() }
    val feedDeferred = async { feedApi.getLatest() }

    Dashboard(
        user = runCatching { userDeferred.await() }.getOrNull(),
        notifications = runCatching { notificationsDeferred.await() }
            .getOrDefault(emptyList()),
        feed = runCatching { feedDeferred.await() }
            .getOrDefault(emptyList())
    )
}

suspend fun fetchWithTimeout(): Data? {
    return withTimeoutOrNull(5000) {
        api.fetchData()
    }
}

suspend fun fetchWithTimeoutAndRetry(): Data {
    repeat(3) { attempt ->
        val result = withTimeoutOrNull(3000) {
            api.fetchData()
        }
        if (result != null) return result
        delay(1000 * (attempt + 1))
    }
    throw TimeoutException("Failed after 3 attempts")
}