1. 일시 중단 함수(Suspending Function)란?
- 일시 중단 함수는 코틀린 코루틴의 핵심 구성 요소로,
suspend키워드로 선언된 함수입니다. - 이 함수들은 실행 중간에 일시 중단되었다가 나중에 다시 재개될 수 있는 특별한 함수입니다.
- 일반 함수와 달리, 실행을 멈추고 스레드를 차단하지 않고 반환할 수 있어 비동기 프로그래밍에 이상적입니다.
기본 구문
suspend fun doSomething() {
// 시간이 걸리는 작업
}
1.1 일시 중단 함수와 일반 함수의 차이
- 일반 함수는 실행이 시작되면 완료될 때까지 해당 스레드를 독점적으로 사용합니다.
- 즉, 함수가 긴 작업을 수행하는 경우 그 스레드는 다른 일을 할 수 없습니다.
- 일시 중단 함수는 특정 지점(suspend 지점)에서 실행을 일시적으로 멈추고, 사용하던 스레드를 반환할 수 있습니다.
- 이 스레드는 다른 작업을 처리하다가, 중단된 작업이 계속될 준비가 되면 같은 스레드나 다른 스레드에서 작업을 재개합니다.
- 일시 중단 함수는 반드시 코루틴 스코프 내부나 다른 일시 중단 함수 안에서만 호출할 수 있습니다.
- 일반 함수에서는 직접 호출할 수 없습니다.
- 컴파일러는 일시 중단 함수를 '상태 머신'으로 변환합니다.
- 이 상태 머신은 함수가 중단된 위치를 기억했다가, 나중에 정확히 그 지점부터 실행을 재개할 수 있게 해줍니다.
// 일반 함수
fun regularFunction() {
// 장시간 실행되는 작업 - 완료될 때까지 스레드 차단
}
// 일시 중단 함수
suspend fun suspendingFunction() {
// 장시간 실행되는 작업 - 스레드를 차단하지 않고 일시 중단 가능
}
// 사용 예시
fun main() = runBlocking {
suspendingFunction() // 코루틴 내에서 호출 가능
}
// 컴파일 오류 - 일시 중단 함수는 코루틴 외부에서 직접 호출할 수 없음
// fun main() {
// suspendingFunction()
// }
2. 코루틴과 일시 중단 함수의 관계
- 일시 중단 함수는 코루틴 시스템의 기반이 되는 핵심 요소입니다.
- 코루틴은 일시 중단 함수를 실행하는 실행 단위이며, 일시 중단 함수는 코루틴의 실행을 일시 중단시키는 메커니즘을 제공합니다.
2.1 상호 의존성
- 일시 중단 함수는 코루틴 내에서만 호출될 수 있습니다.
- 코루틴은 일시 중단 함수를 통해 비차단 방식으로 일시 중단되고 재개됩니다.
- 이 둘의 관계는 다음과 같이 요약할 수 있습니다:
- 코루틴은 일시 중단 함수를 실행하는 컨테이너입니다.
- 일시 중단 함수는 코루틴이 효율적으로 일시 중단되고 재개될 수 있도록 하는 메커니즘입니다.
// 코루틴과 일시 중단 함수의 관계 예시
fun main() = runBlocking {
// 여기서 runBlocking은 코루틴을 시작하는 빌더입니다
println("코루틴 시작")
delay(1000) // 일시 중단 함수 - 코루틴을 일시 중단합니다
println("코루틴 재개")
}
2.2 코루틴 빌더와 일시 중단 함수
- 코루틴 빌더(
launch,async,runBlocking등)는 코루틴을 생성하고 일시 중단 함수를 실행하는 진입점입니다. - 이 빌더들은 일시 중단 함수가 실행될 수 있는 코루틴 컨텍스트를 제공합니다.
fun main() = runBlocking {
// launch는 새 코루틴을 시작하는 빌더
val job = launch {
delay(1000) // 일시 중단 함수
println("코루틴 내부 작업 완료")
}
// async는 결과를 반환하는 코루틴을 시작하는 빌더
val deferred = async {
delay(2000) // 일시 중단 함수
"작업 결과"
}
// await는 일시 중단 함수
val result = deferred.await()
println("결과: $result")
}
3. 일시 중단 함수의 내부 동작 원리
- 일시 중단 함수는 컴파일 시점에 특별한 변환을 거쳐 상태 머신으로 변환됩니다.
- 이 변환 과정은 컨티뉴에이션 패싱 스타일(Continuation-Passing Style, CPS) 변환과 유사합니다.
3.1 컨티뉴에이션(Continuation)
- 컨티뉴에이션은 코루틴이 일시 중단된 후 어디서부터 다시 실행해야 하는지에 대한 정보를 담고 있습니다.
- 모든 일시 중단 함수는 마지막 파라미터로
Continuation객체를 암시적으로 받습니다.
// 컴파일러는 다음과 같이 변환합니다:
suspend fun myFunction(param: Type): Result
// 위 함수는 다음과 유사한 형태로 변환됩니다:
fun myFunction(param: Type, continuation: Continuation<Result>): Any
3.2 상태 머신(State Machine)
- 일시 중단 함수는 여러 상태를 가진 상태 머신으로 변환됩니다.
- 각 상태는 일시 중단 지점을 나타내며, 함수가 재개될 때 어느 지점부터 실행해야 하는지 결정합니다.
suspend fun complexFunction() {
println("상태 0")
delay(1000) // 일시 중단 지점 1
println("상태 1")
delay(1000) // 일시 중단 지점 2
println("상태 2")
}
// 위 함수는 대략 다음과 같이 변환됩니다(단순화된 형태):
fun complexFunction(continuation: Continuation<Unit>): Any {
val state = continuation.state
when (state) {
0 -> {
println("상태 0")
return delay(1000, ContinuationImpl(1))
}
1 -> {
println("상태 1")
return delay(1000, ContinuationImpl(2))
}
2 -> {
println("상태 2")
return Unit
}
}
}
참고
실제 변환은 이보다 훨씬 복잡하지만, 기본 아이디어는 함수가 여러 진입점을 가진 상태 머신으로 변환된다는 것입니다.
4. 일시 중단 함수의 활용 패턴
4.1 순차적 실행
- 일시 중단 함수는 비동기 작업을 순 차적으로 실행하는 데 이상적입니다.
- 코드는 동기식처럼 보이지만 실제로는 비동기적으로 실행됩니다.
suspend fun fetchUserAndPosts(): Pair<User, List<Post>> {
val user = fetchUser() // 첫 번째 API 호출
val posts = fetchPosts(user.id) // 두 번째 API 호출 (첫 번째 결과에 의존)
return user to posts
}
// 사용 예시
suspend fun displayUserData() {
val (user, posts) = fetchUserAndPosts()
displayUser(user)
displayPosts(posts)
}
4.2 병렬 실행
async와await를 사용하여 여러 일시 중단 함수를 병렬로 실행할 수 있습니다.
suspend fun fetchUserAndPostsConcurrently(): Pair<User, List<Post>> = coroutineScope {
val userDeferred = async { fetchUser() }
val postsDeferred = async { fetchPosts("temp_id") } // 병렬로 시작
val user = userDeferred.await()
val posts = postsDeferred.await()
user to posts
}
4.3 오류 처리
- 일시 중단 함수에서 발생한 예외는 일반 함수와 동일한 방식으로 처리할 수 있습니다.
try-catch블록이나 고차 함수를 사용하여 예외를 처리할 수 있습니다.
suspend fun fetchUserSafely(): User? {
return try {
fetchUser()
} catch (e: Exception) {
println("사용자 정보를 가져오는 중 오류 발생: ${e.message}")
null
}
}
// 고차 함수 활용
suspend fun <T> runSafely(block: suspend () -> T): Result<T> {
return try {
Result.success(block())
} catch (e: Exception) {
Result.failure(e)
}
}
// 사용 예시
suspend fun fetchData() {
val userResult = runSafely { fetchUser() }
userResult.onSuccess { user ->
println("사용자: $user")
}.onFailure { error ->
println("오류: $error")
}
}
5. 일시 중단 함수 만들기
5.1 기본 일시 중단 함수 작성
suspend키워드를 사용하여 함수를 일시 중단 함수로 선언합니다.- 내부에서 다른 일시 중단 함수를 호출할 수 있습니다.
suspend fun myCustomSuspendFunction() {
// 다른 일시 중단 함수 호출
delay(1000)
// 일반 함수 호출
regularFunction()
// 추가 작업
}
5.2 코루틴 빌더를 사용한 일시 중단 함수
coroutineScope를 사용하여 새로운 코루틴 스코프를 생성하는 일시 중단 함수를 만들 수 있습니다.- 이는 구조화된 동시성을 보장하는 데 유용합니다.
suspend fun loadDataConcurrently(): CombinedData = coroutineScope {
val part1 = async { loadPart1() }
val part2 = async { loadPart2() }
CombinedData(part1.await(), part2.await())
}
5.3 콜백 API를 일시 중단 함수로 변환
- 기존의 콜백 기반 API를
suspendCoroutine또는suspendCancellableCoroutine을 사용하여 일시 중단 함수로 변환할 수 있습니다.
suspend fun fetchUserFromApi(userId: String): User = suspendCoroutine { continuation ->
// 기존 콜백 기반 API 호출
api.fetchUser(userId, object : Callback<User> {
override fun onSuccess(user: User) {
continuation.resume(user)
}
override fun onError(error: Throwable) {
continuation.resumeWithException(error)
}
})
}
// 취소 지원 버전
suspend fun fetchUserFromApiCancellable(userId: String): User = suspendCancellableCoroutine { continuation ->
val call = api.fetchUser(userId, object : Callback<User> {
override fun onSuccess(user: User) {
continuation.resume(user)
}
override fun onError(error: Throwable) {
continuation.resumeWithException(error)
}
})
// 취소 처리
continuation.invokeOnCancellation {
call.cancel()
}
}
6. 일시 중단 함수와 컨텍스트 전환
6.1 withContext 활용
withContext는 코루틴 컨텍스트를 변경하면서 코드 블록을 실행하는 일시 중단 함수입니다.- 주로 디스패처를 변경하여 다른, 스레드에서 코드를 실행하는 데 사용됩니다.
suspend fun fetchAndProcessData(): ProcessedData {
// IO 스레드에서 데이터 가져오기
val rawData = withContext(Dispatchers.IO) {
api.fetchData() // 네트워크 호출
}
// CPU 집약적인 작업은 Default 디스패처에서 처리
val processedData = withContext(Dispatchers.Default) {
processData(rawData) // 데이터 처리
}
// UI 업데이트는 Main 스레드에서 수행
return withContext(Dispatchers.Main) {
updateUI(processedData)
processedData
}
}
6.2 디스패처 선택 가이드라인
Dispatchers.Main: UI 관련 작업Dispatchers.IO: 파일 I/O, 네트워크 요청, 데이터베이스 작업Dispatchers.Default: CPU 집약적 작업(복잡한 계산, 큰 목록 처리 등)
suspend fun loadAndDisplayImage(imageUrl: String) {
// IO 디스패처에서 이미지 다운로드
val bytes = withContext(Dispatchers.IO) {
downloadImage(imageUrl)
}
// Default 디스패처에서 이미지 처리
val processedBitmap = withContext(Dispatchers.Default) {
processBitmap(bytes)
}
// Main 디스패처에서 UI 업데이트
withContext(Dispatchers.Main) {
displayImage(processedBitmap)
}
}
7. 고급 패턴 및 기법
7.1 Flow와 일시 중단 함수
- Flow는 여러 값을 비동기적으로 방출하는 스트림을 나타냅니다.
- flow 빌더 내에서 일시 중단 함수를 사용하여 비동기 데이터 스트림을 생성할 수 있습니다.
fun fetchNewsPeriodically(): Flow<News> = flow {
while (true) {
val latestNews = fetchLatestNews() // 일시 중단 함수
emit(latestNews) // 결과 방출
delay(60000) // 1분 대기
}
}
// 사용 예시
suspend fun collectNews() = coroutineScope {
fetchNewsPeriodically()
.collect { news ->
displayNews(news)
}
}
7.2 Mutex와 Semaphore
- 코루틴에서 공유 상태에 대한 접근을 제어하기 위해 일시 중단 기반의 동기화 프리미티브를 사용할 수 있습니다.
suspend fun safeIncrement(counter: AtomicInteger, mutex: Mutex) {
mutex.withLock {
// 이 블록은 한 번에 하나의 코루틴만 실행 가능
val currentValue = counter.get()
delay(10) // 시뮬레이션된 작업
counter.set(currentValue + 1)
}
}
7.3 타임아웃 처리
withTimeout또는withTimeoutOrNull을 사용하여 일시 중단 함수의 실행 시간을 제한할 수 있습니다.
suspend fun fetchWithTimeout(url: String): String {
return withTimeout(5000L) { // 5초 제한
fetchData(url) // 일시 중단 함수
}
}
// null 반환 버전
suspend fun fetchWithTimeoutOrNull(url: String): String? {
return withTimeoutOrNull(5000L) {
fetchData(url)
}
}
8. 실제 활용 사례
8.1 Android에서의 활용
- Android에서는 ViewModel, Repository, 각종 유틸리티 클래스에서 일시 중단 함수를 활용할 수 있습니다.
class UserRepository(private val api: UserApi) {
suspend fun getUser(userId: String): User {
return withContext(Dispatchers.IO) {
api.fetchUser(userId)
}
}
suspend fun updateUserProfile(user: User): User {
return withContext(Dispatchers.IO) {
api.updateUser(user)
}
}
}
class UserViewModel(private val repository: UserRepository) : ViewModel() {
private val _user = MutableLiveData<User>()
val user: LiveData<User> = _user
fun loadUser(userId: String) {
viewModelScope.launch {
try {
val result = repository.getUser(userId)
_user.value = result
} catch (e: Exception) {
// 오류 처리
}
}
}
}
8.2 서버 사이드에서의 활용
- 서버 애플리케이션에서는 요청 처리, 데이터베이스 접근, 외부 API 호출 등에 일시 중단 함수를 활용할 수 있습니다.
class OrderService(
private val repository: OrderRepository,
private val paymentService: PaymentService,
private val notificationService: NotificationService
) {
suspend fun processOrder(order: Order): OrderResult {
// 트랜잭션 처리
val savedOrder = repository.saveOrder(order)
// 결제 처리
val paymentResult = paymentService.processPayment(order.paymentDetails)
// 결제 상태 업데이트
val updatedOrder = repository.updatePaymentStatus(
savedOrder.id,
paymentResult.status
)
// 알림 발송
notificationService.sendOrderConfirmation(updatedOrder)
return OrderResult(updatedOrder, paymentResult)
}
}
// Ktor 서버에서의 사용 예
fun Application.configureRouting() {
val orderService = OrderService(...)
routing {
post("/orders") {
val order = call.receive<Order>()
val result = orderService.processOrder(order)
call.respond(result)
}
}
}
9. 모범 사례와 권장 사항
9.1 일시 중단 함수 설계 원칙
- 순수성 유지: 일시 중단 함수는 가능한 한 부작용을 최소화하고 예측 가능한 결과를 반환해야 합니다.
- 취소 지원: 일시 중단 함수는 취소를 적절히 처리해야 합니다.
- 컨텍스트 준수: 특정 스레드에서 실행해야 하는 코드는 적절한 디스패처를 사용해야 합니다.
// 좋은 예시
suspend fun fetchData(): Data = withContext(Dispatchers.IO) {
// 네트워크 요청
}
// 나쁜 예시 - 컨텍스트 지정 없음
suspend fun fetchData(): Data {
// 이 함수가 어떤 스레드에서 실행될지 불명확함
}
9.2 안티 패턴
- 블로킹 코드: 일시 중단 함수 내에서 스레드를 차단하는 블로킹 코드를 사용하지 마세요.
- 스레드 지역 변수 의존: 일시 중단 함수는 스레드 간에 이동할 수 있으므로 ThreadLocal에 의존하면 안 됩니다.
- 무거운 계산: CPU 집약적인 작업은 적절한 디스패처에서 실행해야 합니다.
// 나쁜 예시 - 블로킹 코드
suspend fun badFunction() {
Thread.sleep(1000) // 스레드 차단 - delay(1000) 사용 권장
}
// 좋은 예시 - 적절한 디스패처 사용
suspend fun heavyComputation(): Result = withContext(Dispatchers.Default) {
// CPU 집약적 작업
}
9.3 디버깅 팁
- 로깅: 코루틴 컨텍스트와 함께 로그를 남겨 디버깅을 용이하게 합니다.
- 코루틴 이름 지정: 코루틴에 이름을 부여하여 디버깅을 용이하 게 합니다.
- 코루틴 디버거 사용: IntelliJ IDEA나 Android Studio의 코루틴 디버거를 활용합니다.
suspend fun debuggableFunction() = coroutineScope {
launch(CoroutineName("DataLoader") + Dispatchers.IO) {
println("코루틴 시작: ${coroutineContext[CoroutineName]}")
// ...
}
}
10. 결론
- 일시 중단 함수는 코틀린 코루틴 시스템의 핵심 구성 요소로, 비동기 코드를 동기 코드처럼 작성할 수 있게 해줍니다.
- 이 함수들은 코루틴 내에서 실행되며, 스레드를 차단하지 않고 일시 중단되었다가 재개될 수 있습니다.
- 일시 중단 함수는 컴파일 시점에 상태 머신으로 변환되어 효율적인 비동기 코드 실행을 가능하게 합니다.
- 적절한 패턴과 모범 사례를 따르면 일시 중단 함수를 사용하여 가독성 높고 유지보수하기 쉬운 비동기 코드를 작성할 수 있습니다.