TIL

9강 코루틴과 Continuation

Continuation

• suspend 함수가 다른 suspend 함수를 호출하는 아래 예제를 살펴보자
• findUser 함수에서 findProfile과 findImage 함수를 호출한다.

class UserService {

  private val userProfileRepository = UserProfileRepository()
  private val userImageRepository = UserImageRepository()
  
  suspend fun findUser(userId: Long): UserDto {
    // 0단계 - 초기 시작
    
    // 1차 중단
    val profile = userProfileRepository.findProfile(userId) 
    
    // 1단계 - 1차 중단 후 재시작
    
    // 2차 중단
    val image = userImageRepository.findImage(profile) 
    
    // 2단계 - 2차 중단 후 재시작
    return UserDto(profile, image)
  } 
}

• Continuation 인터페이스 만들어서 중단과 재시작 단계들을 라벨로 표시해보자.

// 점점 더 많은 기능들이 추가될 것이다.
interface Continuation {
}

• findUser 메서드 안에서 Continuation을 익명 클래스로 구현해서 사용할 수 있다.
  • 익명 클래스 구현체 변수 이름이 sm인 이유는 상태 머신 (state machine)에서 따왔기 때문
  • 각 단계에 따라 sm 내부에 결과를 저장하고 label을 증가시킨다.

suspend fun findUser(userId: Long): UserDto {
  val sm = object : Continuation {
    var label = 0
    
    // label == 2일 때 아래에서 UserDto를 반환하기 위해 필요
    var profile: Profile? = null
    var image: Image? = null
  }
  
  when (sm.label) {
    0 -> { // 0단계 - 초기 시작
      sm.label = 1
      
      sm.profile = userProfileRepository.findProfile(userId)
    }
    1 -> { // 1단계 - 1차 중단 후 재시작
      sm.label = 2
      
      sm.image = userImageRepository.findImage(sm.profile!!)
    }
    2 -> { // 2단계 2차 중단 후 재시작
      return UserDto(sm.profile!!, sm.image!!)
    } 
  }
}

• 위 코드로는 0단계만 호출되고 함수가 종료되고 말 것이다.
• 이를 해결하기 위해선 Continuation을 전달하며 Callback으로 활용해야 한다.
  • Continuation에 resumeWith라는 추상 메서드를 만든다.
    • sm이 resumeWith를 오버라이드하며 findUser를 다시 호출할 것이다.
  • suspend 함수 전부에 마지막 매개변수로 Continuation을 전달해보자

interface Continuation {
  suspend fun resumeWith(data: Any?)
}

suspend fun findUser(userId: Long, continuation: Continuation?): UserDto {
  val sm = continuation ?: object : Continuation { // 무한 루프를 피하기 위해 null인 경우에만 label==0인 sm 생성
    var label = 0
    var profile: Profile? = null
    var image: Image? = null
    
    override suspend fun resumeWith(data: Any?) {
	    when (label) { // Continuation 내부에서 label을 증가
	      0 -> {
  	      profile = data as Profile
  	      label = 1
  	    }
	      1 -> {
	        image = data as Image
	        label = 2
	      }
	    }
      findUser(userId, this) // Continuation 자신을 전달
    }
  }
  
  when (sm.label) {
    0 -> {
      userProfileRepository.findProfile(userId, sm) // sm 전달
    }
    1 -> {
      userImageRepository.findImage(sm.profile!!, sm) // sm 전달
    }
  }
  return UserDto(sm.profile!!, sm.image!!)
}

class UserProfileRepository {
  suspend fun findProfile(userId: Long, continuation: Continuation) { // 리턴값이 필요 없어짐
    delay(100L)
    continuation.resumeWith(Profile())
  } 
}

class UserImageRepository {
  suspend fun findImage(profile: Profile, continuation: Continuation) { // 리턴값이 필요 없어짐
    delay(100L)
    continuation.resumeWith(Image())
  }
}

• 위 코드라면 resumeWith()가 불리면서 내부에서 findUser를 재귀적으로 호출하기에 label에 따라 로직들이 순차적으로 실행될 것이다.
• 핵심은 Continuation을 전달하는 것

1. findUser 최초 호출
   1. label이 0인 sm : Continuation 생성
2. findProfile에 sm 전달하며 호출
   1. Profile을 생성 후 sm.resueWith 호출
3. sm 내부에서 label에 따라 알맞은 결과 데이터 저장
4. Continuation이 자신을 넘기며 다시 findUser 호출
   1. sm : Continuation이 null이 아니므로 생성하지 않고 그대로 사용
   2. label 1인 sm으로 로직 동작
5. …
6. label 2가 되면 결과를 리턴

코루틴의 Continuation

• 실제로 suspend 함수만으로 구현했던 초기 코드를 디컴파일 해보면 우리가 만든 Continuation 코드와 유사하게 디컴파일된다.
• 즉 코루틴은
  • Continuation을 전달하며
  • label로 각 상황을 매기고
  • 콜백 패턴을 사용해서
  • 함수를 서로 연결한다고 정리할 수 있다.
• 이러한 방식을 Continuation Passing Style (CPS)라고 한다.

// 실제 Continuation 인터페이스이다.
public interface Continuation<in T> {
  public val context: CoroutineContext
  public fun resumeWith(result: Result<T>)
}