Jack.dev.blog

전체 화면 로딩 23번을 2번으로: 설문 저장을 백그라운드 직렬 큐로

온보딩 설문에서 답할 때마다 서버 응답을 기다리던 구조를, 답변을 백그라운드 직렬 큐로 보내고 꼭 필요한 두 곳에서만 기다리도록 바꾼 구현기예요.

FlutterBLoCOnboardingDjango

들어가며: 답을 하나 고를 때마다 화면이 멈췄다

저는 Flutter 로 웰니스 앱을 만들고, 앱이 부르는 Django·FastAPI 서버도 같이 맡고 있어요. 앱을 처음 켠 사람은 몸 상태와 생활 습관을 묻는 온보딩 설문을 거쳐요. 수면 시간, 앉아 있는 시간, 복용 중인 약 같은 문항이에요.

QA 에서 이런 지적이 왔어요. “설문 문항이 넘어갈 때마다 로딩이 떠서 느리다.” 확인해 보니 답을 하나 고를 때마다 화면 전체를 덮는 로딩이 떴다가 사라지고 나서야 다음 문항으로 넘어갔어요. 설문은 최대 23문항이었으니, 사용자는 로딩을 23번 봤어요.

이 글은 그 23번을 2번으로 줄인 과정이에요. 답변 저장을 기다리지 않고 백그라운드 직렬 큐로 보내도록 바꿨고, 그러면서 이런 질문에 답해야 했어요.

  • 기다리지 않으면 다음 문항은 무엇으로 정하나
  • 큐는 왜 한 번에 하나씩(직렬) 보내야 하나
  • 전송이 실패하거나 앱이 꺼지면 답변은 어떻게 되나
  • 그래도 꼭 기다려야 하는 2곳은 어디고, 왜인가

화면 전환마다 서버 응답을 await 하고 있는 분, 또는 “낙관적 업데이트를 하고 싶은데 서버가 순서를 검증해서 망설여지는” 분께 참고가 될 거예요.

23번은 이렇게 셌어요

먼저 숫자의 근거부터 밝힐게요. 23은 측정값이 아니라 코드 경로로 센 값이에요.

바꾸기 전 BLoC 은 답변 하나를 받으면 이렇게 처리했어요(줄인 코드예요).

Future<void> _onSelectAnswer(SelectAnswerEvent event, Emitter<SurveyState> emit) async {
  final data = {event.stepType.value: event.answerId};

  await _onboardingUseCase
      .updateOnboardingStep(data)                       // POST /onboarding
      .onStart(() => _emitSideEffect(LoadingEffect(isLoading: true)))
      .onSuccess((stepModel) async {
        await _navigateToNextStep(emit, stepModel.step); // 응답의 next_step 으로 이동
      })
      .onFinal(() => _emitSideEffect(LoadingEffect(isLoading: false)))
      .execute();
}

페이지는 LoadingEffect(isLoading: true) 를 받으면 전체 화면 로딩을 띄웠어요. 여기서 볼 것은 두 가지예요. 문항 하나당 POST 1건과 로딩 1번이 묶여 있고, 다음 문항은 서버 응답의 next_step 으로만 정해져요. 복수 선택 문항의 제출 경로도 같은 모양이었어요.

그러면 로딩 횟수는 곧 사용자가 답하는 설문 문항 수예요. 문항 수는 사용자 조건에 따라 달랐어요. 서버 응답을 계정 조건별로 실제로 받아서 센 결과예요.

계정 조건 설문 문항 수 = 바꾸기 전 로딩 횟수
남성 21
여성, 생리 주기 “해당 없음” 22
여성, 생리 주기 “규칙적” 23

이 글의 23은 가장 긴 경우(여성·규칙적)예요. 뒤에 나올 “2번”도 같은 조건, 같은 정의(설문 구간에서 전체 화면 로딩이 뜨는 횟수)로 셌어요.

처음의 가정: 다음 문항을 몰라서 기다리는 줄 알았다

처음에는 이렇게 생각했어요. “다음 문항이 무엇인지는 서버가 답을 보고 정하니까, 응답을 기다릴 수밖에 없겠지.” 그렇다면 해법은 서버를 빠르게 하거나, 서버 로직을 앱으로 옮기는 것뿐이에요.

그런데 코드를 따라가 보니 이 가정이 틀렸어요.

  • 서버는 이미 전체 순서를 주고 있었어요. 프로필 응답의 onboarding_steps 에 그 사용자에게 보여 줄 스텝 목록이 계층 구조로 들어 있었어요.
  • 앱도 그 목록으로 모든 페이지를 미리 만들어 두고 있었어요. 설문 화면은 그 목록 길이만큼의 PageView 였어요.
  • 서버의 next_step 계산과 스텝 목록 생성은 같은 판정 함수(어떤 스텝을 건너뛸지 정하는 함수)를 썼어요. 즉 next_step 은 목록에서 바로 다음 항목과 정의상 같아요.
  • 심지어 앱에는 로컬에서 다음 스텝을 구하는 함수도 있었어요. 쓰이지 않고 있었을 뿐이에요.

원인은 “다음 단계를 몰라서”가 아니었어요. 응답을 기다리는 것 자체가 문제였어요.

서버를 빠르게 하는 길도 따져 봤어요. 답변 저장 POST 1건은 DB 왕복이 11~14번이었어요. 그런데 기능을 바꾸지 않고 줄일 수 있는 건 1~4번뿐이었어요. 다음 스텝을 정하려면 방금 저장한 값을 다시 읽어야 했거든요(저장 후 읽기가 곧 “답에 따라 문항이 생기는” 동작의 원리였어요). 기대 이득은 10~30% 정도로 봤고, 줄여도 로딩은 여전히 23번 떠요. 그래서 서버 최적화는 미루고 기다리지 않는 쪽을 골랐어요.

기다리지 않고 넘어가기: 답은 큐에, 화면은 예측으로

새 구조는 이래요.

설문 페이지
   │ (탭)
SurveyBloc ──enqueue──▶ OnboardingStepQueue (앱 전체에 하나)
   ▲                         │ 한 번에 1건씩 POST /onboarding
   │◀── Acked / Failed ──────┤
   │                         └──▶ 로컬 저장소 (미전송 답변, 회원 ID 별)
   │
   └─ 응답을 기다리지 않고 바로 다음 페이지로

BLoC 은 답변을 큐에 넣고 바로 다음 페이지로 넘어가요. 서버 응답은 나중에 이벤트로 받아서 예측과 맞는지 대조만 해요.

이 글에서는 이 방식을 낙관적 진행이라고 부를게요. 서버가 “다음은 이 문항”이라고 말해 주기 전에, 앱이 같은 목록으로 먼저 계산해서 넘어가는 거예요.

await _stepQueue.enqueue(step: stepType, value: value);

// 예측은 서버와 같은 기준(전체 스텝 목록)으로 한다.
final index = _flattenSteps.indexOf(stepType);
final hasNext = index != -1 && index + 1 < _flattenSteps.length;
final predictedNext = hasNext ? _flattenSteps[index + 1] : OnboardingStepType.unknown;
_predictedNext[stepType] = predictedNext;   // 나중에 서버 응답과 대조할 기록

final pageIndex = state.surveyStepInfos.indexWhere((info) => info.stepType == predictedNext);
if (pageIndex == -1) {
  await _completeSurvey(emit);   // 다음 스텝이 설문이 아니다 = 설문 끝
  return;
}
_moveToPage(pageIndex);

여기서 걸려 넘어지기 쉬운 곳이 하나 있어요. 예측의 기준 목록이에요.

화면에 보이는 건 설문 문항만 걸러 낸 목록(surveyStepInfos)이에요. 이걸로 “다음 문항”을 예측하고 싶어지는데, 그러면 서버와 갈릴 수 있어요. 서버의 next_step 은 걸러 내기 전 전체 목록의 다음 항목이거든요. 지금은 설문 구간 중간에 설문이 아닌 스텝이 없어서 우연히 같은 답이 나와요. 하지만 서버 코드에는 주석 처리된 스텝이 9개 있었고, 그중 하나만 설문 사이에 다시 켜져도 이미 배포된 앱의 예측이 전부 틀어져요.

그래서 예측은 전체 목록(flatten) 기준, 화면 이동만 설문 목록 기준으로 나눴어요. 전체 목록 기준이면 서버 응답과 정의상 같은 값이 나와요. 이 두 기준이 다시 섞이지 않도록 회귀 테스트로 고정했어요.

큐는 왜 직렬이어야 했나

답변을 기다리지 않는다면, 그냥 문항마다 POST 를 바로 쏘면 되지 않을까요? 그러면 큐도 필요 없어요.

안 되는 이유는 서버에 있었어요. 서버는 답변을 저장하기 전에 앞 스텝이 모두 저장됐는지 검증해요(_validate_previous_steps_completed). 앞서 나간 요청은 “이전 단계 미완료” 에러로 거부해요. 사용자가 빠르게 3문항을 답해서 요청 3건이 동시에 나가면, 네트워크 사정으로 3번째가 2번째보다 먼저 도착할 수 있어요. 그러면 3번째는 거부돼요.

서버가 순서를 검증하는 한, 보내는 쪽도 순서를 지켜야 합니다.

그래서 큐는 한 번에 1건씩 보내고, 앞 건의 응답을 받은 뒤에야 다음 건을 보내요. 예외도 두지 않았어요. 뒤에 나올 “기다려야 하는 문항”조차 큐를 우회해 직접 POST 하지 않아요. 우회하면 큐에서 기다리던 앞 문항보다 먼저 도착해서 같은 검증에 걸려요.

직렬로 보내는 일꾼은 이렇게 하나만 돌게 했어요.

/// 진행 중인 drain 이 있으면 그 Future 를 재사용한다 — 이것이 곧 재진입 가드다.
void _kick() {
  _drainFuture ??= _drain().whenComplete(() => _drainFuture = null);
}

Future<void> _drain() async {
  while (_pending.isNotEmpty && !_stopped) {
    final item = _pending.first;
    final result = await _onboardingUseCase.updateOnboardingStep(item.toRequestBody());
    final succeeded = result.fold(
      (model) { _emit(Acked(step: item.step, serverNextStep: model.step)); return true; },
      (error, _) { _emit(Failed(step: item.step, error: error)); return false; },
    );
    if (!succeeded) { _stopped = true; return; }   // 실패하면 멈춘다
    _pending.remove(item);
    await _persist();
  }
}

볼 것은 _drainFuture 하나로 일꾼이 둘 생기는 걸 막는다는 점이에요. isSending 같은 bool 플래그를 따로 두면 이 Future 와 플래그가 어긋날 수 있어서, 가드를 하나로 뒀어요.

순서 검증 말고 직렬이어야 하는 이유가 하나 더 있어요. 덮어쓰기예요. 사용자가 뒤로 가서 답을 바꾸면 같은 스텝의 답이 두 번 나가요. 동시에 보내면 바꾼 답이 옛 답보다 먼저 도착할 수 있고, 그러면 나중에 도착한 옛 답이 마지막 값으로 저장돼요. 직렬로 보내면 서버에 도착하는 순서가 사용자가 답한 순서와 같아요.

큐는 여기서 한 걸음 더 나가요. 같은 스텝이 아직 대기 중이면 새로 줄을 세우지 않고 그 자리를 새 값으로 바꿔요. 옛 답은 어차피 덮일 값이라 보낼 이유가 없고, 뒤에 나올 전송 실패 후 재답변도 이 규칙으로 풀려요. 단, 지금 전송 중인 항목은 건드리지 않아요.

// 전송 중인 항목(맨 앞)은 바꿀 수 없으므로 탐색에서 뺀다.
final searchStart = _inFlight == null ? 0 : 1;
final existingIndex = _pending.indexWhere((item) => item.step == step, searchStart);
if (existingIndex == -1) {
  _pending.add(next);
} else {
  _pending[existingIndex] = next;   // 대기 중인 옛 답을 새 답으로 교체
}
await _persist();   // 보내기 전에 먼저 디스크에
_kick();

이전 글에서 BLoC 이벤트를 sequential() 로 줄 세우는 이야기를 했어요. 이 큐는 그것과 다른 층이에요. sequential() 은 BLoC 하나 안에서 이벤트 처리 순서를 정하고, BLoC 이 닫히면 같이 사라져요. 이 큐는 앱 전체에 하나(registerLazySingleton)로 두고 디스크에도 남겨서, 사용자가 설문 화면을 벗어나거나 앱이 꺼져도 보내던 순서를 이어 가요.

꼭 기다려야 하는 두 곳

모든 문항을 기다리지 않을 수는 없었어요. 기다려야 하는 곳은 정확히 두 종류였어요.

첫째, 답에 따라 뒤 문항이 바뀌는 문항

생리 주기가 규칙적인지 묻는 문항이 그래요. “규칙적” 또는 “불규칙”이라고 답하면 서버가 마지막 생리 시작일 문항을 목록에 새로 넣어요. 답을 저장하기 전에는 목록에 그 문항이 없으니, 앱이 아무리 정확하게 예측해도 다음 문항을 맞힐 수 없어요.

이 글에서는 이런 문항을 분기 문항이라고 부를게요.

처음에는 앱이 직접 목록을 고치는 설계를 떠올렸어요. “규칙적이면 생리 시작일 문항을 끼워 넣는다”를 앱에 쓰는 거예요. 버린 이유는 세 가지예요.

  • 앱이 생리 조건 하나만 알게 돼요. 서버에는 성별, GLP-1 사용 여부까지 조건이 셋이었어요.
  • 문항을 끼우면 진행 바의 분모 같은 그룹 진행도도 손으로 다시 계산해야 해요.
  • 서버에 조건이 늘면 앱과 서버를 같이 배포해야 해요. 이미 깔린 앱은 조용히 어긋나요.

대신 어느 문항이 분기 문항인지 서버가 알려 주게 했어요. 서버 응답의 스텝 항목에 affects_next_steps 필드를 하나 더했어요.

{ "step": "MENSTRUAL_REGULARITY", "id": 1, "affects_next_steps": true }
{ "step": "LAST_MENSTRUAL_DATE",  "id": 2 }

이 필드는 분기 문항에만 붙어요. 나머지 항목에는 False 가 아니라 None 을 넣었고, 서버가 None 을 빼고 직렬화하기 때문에 기존 응답과 바이트가 같아요. 구버전 앱은 이 키를 모르고 지나가요. 결과(생리 시작일 문항)가 아니라 원인(그 문항을 부르는 답) 에 표시한 것도 의도예요. 결과에 표시하면 어느 답이 그걸 부르는지 앱이 알 수 없거든요.

앱은 이 필드와 로컬 폴백 집합을 OR 해서 판정해요. 서버가 아직 이 필드를 배포하지 않았어도 안전한 쪽(기다리는 쪽)으로 남게요.

bool _isBranchingStep(OnboardingStepType stepType) {
  final info = state.surveyStepInfos.where((info) => info.stepType == stepType).firstOrNull;
  return (info?.affectsNextSteps ?? false) || _fallbackBranchingSteps.contains(stepType);
}

static const _fallbackBranchingSteps = {OnboardingStepType.menstrualRegularity};

분기 문항에서는 큐에 넣은 뒤 큐가 빌 때까지(flush) 기다리고, 프로필을 다시 읽어 목록을 새로 만든 다음 서버가 정한 스텝으로 이동해요. 로딩은 이 구간에만 떠요. 목록을 바꾸는 권한은 여전히 서버에 있어요.

서버가 표시하는 분기 문항은 세 개였지만, 그중 성별과 GLP-1 사용 여부는 설문 앞의 채팅형 구간에 있어요. 설문 구간에 걸리는 분기 문항은 하나뿐이에요.

둘째, 마지막 문항

설문을 마치면 바로 건강 분석 화면으로 넘어가요. 분석 API 는 그때까지의 모든 답변을 읽어요. 큐에 보내지 못한 답이 남은 채 넘어가면 불완전한 데이터로 분석이 돌아가요.

그래서 마지막 문항에서는 큐를 끝까지 비우고(flush) 나서 넘어가요. 이 지점을 이 글에서는 합류 지점이라고 부를게요. 흩어져 보내던 답변이 여기서 한 번 모여요.

Future<void> _completeSurvey(Emitter<SurveyState> emit) async {
  _emitSideEffect(LoadingEffect(isLoading: true));
  final flushed = await _stepQueue.flush();
  _emitSideEffect(LoadingEffect(isLoading: false));

  if (!flushed) {
    return;   // 실패 이벤트가 이미 그 문항으로 되돌렸다. 여기서 성공을 내면 미전송 답으로 분석이 돈다.
  }
  _emitSideEffect(SuccessEffect());
}

답변은 고를 때마다 바로 보내고 있으니, 마지막 문항에 도착할 즈음엔 큐가 이미 거의 비어 있을 거라고 봤어요. 그래서 이 로딩은 대개 짧게 끝나리라 예상했어요. 실제로 얼마나 기다리는지는 완료 시점에 final_flush_wait_ms 로 남기게 했어요. [확인 필요: 배포 후 final_flush_wait_ms 실측 분포]

이렇게 해서 23번이 2번이 됐어요. 분기 문항 1번 + 합류 지점 1번이에요. 분기 문항이 없는 남성 계정은 1번이에요. (앱이 꺼진 뒤 미전송 답을 들고 다시 들어온 드문 경우에는, 그 답을 보내는 동안 진입 시점에 로딩이 한 번 더 떠요.)

실패하면 멈추고, 앱이 꺼져도 남는다

기다리지 않는다는 건, 실패를 사용자가 이미 다음 문항에 가 있을 때 알게 된다는 뜻이에요. 상황별로 이렇게 정했어요.

상황 동작
전송 실패 토스트를 띄우고 실패한 문항으로 화면을 되돌려요
실패 지점 뒤의 답변 보내지 않고 보류해요. 건너뛰어 보내면 서버가 순서 검증으로 줄줄이 거부해요
사용자가 그 문항을 다시 답함 같은 스텝 교체 규칙이 실패한 항목을 새 값으로 바꾸고, 큐가 다시 돌아요
앱이 꺼졌다가 다시 설문에 들어옴 로컬에 남은 답을 불러와, 서버에 이미 저장된 건 버리고 나머지만 보내요
회원 ID 를 아직 모름 디스크 저장을 건너뛰고 메모리로만 돌아요

큐 안에서 따로 재시도하지 않은 것도 결정이었어요. 네트워크 계층(dio 인터셉터)이 이미 타임아웃·연결 오류를 재시도하고 있었거든요. 큐까지 올라온 실패는 재시도를 다 쓴 실패라서, 바로 사용자에게 보여 주는 게 맞다고 봤어요.

앱 종료에 대비한 규칙은 하나였어요. 큐에 넣을 때 보내기보다 디스크 저장이 먼저예요. 앱이 갑자기 죽어도 답이 남아 있어야, 다시 들어왔을 때 이어 할 지점이 지금보다 뒤로 밀리지 않아요. 저장 키는 회원 ID 로 나눴어요(onboarding_pending_steps_{memberId}). 한 기기에서 다른 계정으로 로그인했을 때 남의 답이 섞이지 않게요.

재개할 때 서버에 이미 저장된 답을 먼저 걸러 내는 단계가 왜 필요한지는 한 번 더 짚을게요. “POST 는 성공했는데 응답을 받기 전에 앱이 죽은” 경우가 있어요. 이때 로컬에는 답이 남아 있어서 다시 보내게 돼요. 대부분의 답은 같은 값을 다시 써도 괜찮아요. 그런데 생리 시작일 답은 서버가 저장할 때마다 생리 주기와 일일 기록을 새로 만들어요. 두 번 보내면 기록이 두 벌 생겨요. 그래서 재개할 때 프로필을 먼저 읽어, 이미 값이 있는 문항은 큐에서 버린 뒤에 보내요.

예측이 틀리면 어제의 방식으로 돌아간다

낙관적 진행은 “서버가 준 목록으로 계산한 다음 문항 = 서버의 next_step” 이라는 전제 위에 서 있어요. 이 전제는 오늘은 맞지만, 서버가 순서 규칙을 바꾸면 깨질 수 있어요. 그때 이미 배포된 앱은 어떻게 될까요?

그래서 예측을 버리지 않고 기록해 뒀어요. 큐가 응답을 받을 때마다 예측과 대조해요.

큐 이벤트 처리
응답의 next_step == 예측 아무것도 안 해요
응답의 next_step != 예측 강등: 낙관적 진행을 끄고, 남은 큐를 버리고, 프로필을 다시 읽어 서버가 말한 스텝으로 이동해요. 이후 문항은 바꾸기 전처럼 한 문항씩 기다려요
“이전 단계 미완료” 로 거부됨 순서 문제라서 위와 같이 강등해요
그 밖의 전송 실패 토스트 + 되돌리기. 낙관적 진행은 유지해요(네트워크 문제일 뿐이라서요)

이 작업에서 가장 중요하게 본 성질이에요.

서버가 순서를 바꿔도 데이터가 깨지지 않고, 느려질 뿐입니다.

강등은 오류가 아니라 설계된 안전장치가 작동한 거라서, 크래시 지표에 잡히는 치명 오류(fatalError)가 아니라 비치명 오류로만 남겼어요. 서버가 스텝 하나를 추가하는 순간 필드의 구버전 앱 전체가 동시에 이 경로를 탈 텐데, 예상된 결과로 알림을 울릴 이유가 없었어요.

강등에도 함정이 하나 있었어요. 큐는 응답 하나를 이벤트로 알린 뒤, BLoC 이 그걸 처리하기 전에 이미 다음 건을 보내고 있을 수 있어요. 첫 응답이 강등을 일으켰다면 그 뒤에 도착한 응답은 버린 세대의 것이에요. 그대로 처리하면 강등이 두 번 돌아 토스트와 페이지 이동이 겹쳐요. 그래서 강등 뒤에 도착한 큐 이벤트는 모두 버리게 했어요.

같은 큐 위에 얹힌 두 번째 구간: 프로그램 설정

이 큐를 만들고 몇 주 뒤, 설문 뒤에 프로그램 설정 구간을 붙이는 작업이 이어졌어요. 끼니 시각, 단식, 걷기 목표, 수면 목표 같은 걸 묻는 9개 스텝(화면 16개) 이에요. 이 구간도 같은 설문 페이지와 같은 BLoC, 같은 큐를 그대로 탔어요.

서버 쪽에서는 이 9스텝을 받는 API 를 v2 로 새로 냈어요(/api/v2/onboarding, /api/v2/members/me/profile). v1 을 부르는 구버전 앱에는 새 스텝이 목록에도, next_step 에도 안 보이게 하고, v1 으로 새 스텝을 저장하려 하면 거부하게 했어요. 구버전 앱이 모르는 스텝 이름을 받으면 “알 수 없는 스텝 → 홈 → 홈이 다시 온보딩으로 돌려보냄” 의 무한 루프에 빠지기 때문이에요. 앱이 v2 로 바꿔 배포하는 시점이 곧 사용자에게 새 구간이 보이는 시점이 됐어요.

큐와 관련해서는 서버가 하나를 일부러 지켰어요. 새 9스텝에는 affects_next_steps 를 하나도 붙이지 않았고, 그걸 테스트로 고정했어요. 하나라도 붙으면 앱이 그 문항에서 분기 문항으로 판정해 로딩을 띄우고 기다리거든요. 앞에서 만든 서버 신호가 로딩 횟수를 서버가 통제하는 손잡이가 된 셈이에요.

그런데 이 구간을 붙이면서 낙관적 진행의 한계가 하나 드러났어요. 설문의 끝은 예측할 수 없었어요. 예측에 쓰는 목록에는 설문 스텝만 들어 있어서, 마지막 문항 다음은 언제나 “알 수 없음”으로 나와요. 설문 뒤가 늘 건강 분석이던 시절에는 그래도 됐어요. 하지만 설문 뒤에 다른 구간이 붙자, 앱이 “모르겠다”를 기본값(건강 분석)으로 읽어 이미 지나온 분석 화면으로 되돌아가는 증상이 실기기에서 나왔어요.

고친 방법은 이 큐가 이미 가진 것이었어요. 합류 지점에서 큐를 비우고 나면 마지막 POST 의 응답이 이미 도착해 있어요. 그래서 설문 밖 첫 목적지만큼은 예측 대신 큐가 마지막으로 받은 서버의 next_step 을 쓰게 했어요. 문항 사이는 예측으로, 구간의 경계는 서버 응답으로 나눈 거예요.

정리하며: 기다림을 없앤 게 아니라 옮겼다

같은 조건(여성·규칙적), 같은 정의로 전후를 놓으면 이래요.

바꾸기 전 바꾼 뒤
설문 구간 전체 화면 로딩 23번 (남성 21번) 2번 (남성 1번)
사용자가 기다리는 지점 모든 문항 분기 문항 1개, 마지막 문항(합류 지점)
문항당 서버 요청 1건 1건 (그대로)
다음 문항을 정하는 근거 서버 응답의 next_step 서버가 준 목록으로 예측, 응답과 대조
서버가 순서를 바꾸면 그대로 따라감 예측이 틀린 걸 감지하고 바꾸기 전 방식으로 강등

23과 2는 모두 코드 경로로 센 값이에요. [확인 필요: 배포 빌드 실기기에서 로딩 횟수를 직접 센 결과]

요청 수는 줄이지 않았어요. 기다림을 없앤 게 아니라, 사용자가 보지 않는 곳으로 옮긴 거예요. 답을 고르는 동안 요청은 뒤에서 하나씩 나가고, 사용자가 기다리는 건 정말 기다려야 하는 두 곳뿐이에요.

처음에 저는 “서버가 다음을 정하니까 기다릴 수밖에 없다”고 생각했어요. 실제로는 서버가 답을 미리 주고 있었는데 쓰지 않고 있었어요. 돌아보면 응답을 기다리는 코드는 대개 “응답에만 있는 정보가 필요해서”가 아니라 “처음에 그렇게 짰으니까” 기다리고 있었어요.

화면 전환마다 await 하는 곳이 있다면 세 가지를 물어보세요.

  1. 지금 기다리는 응답에만 있는 정보가 정말 있나? 이미 받아 둔 목록이나 상태로 계산할 수 있지 않나?
  2. 서버가 순서를 검증하나? 그렇다면 동시 전송 대신 직렬 큐가 필요하고, 실패한 항목 뒤는 보류해야 해요.
  3. 예측이 틀렸을 때 데이터가 깨지나, 느려지기만 하나? 느려지기만 하게 만들 수 없다면 낙관적 진행을 쓰지 않는 게 맞아요. 답에 따라 뒤가 바뀌는 문항처럼 예측의 입력 자체가 아직 없는 곳에서는 기다려야 해요.
main 글 35개 Markdown UTF-8