테스트에서는 멀쩡한 코드가 부하가 걸릴 때만 깨진다면 어디부터 봐야 할까? 같은 입력으로 다시 돌려도 재현되지 않는 상황은 동시성 장애를 처음 배우는 개발자에게 막막할 수 있다. 실행 순서에 따른 경쟁 상태, 중간 실패로 남는 부분 쓰기, 반복 요청의 효과를 다루는 멱등성을 나누어 보면 확인할 지점이 드러난다. 재시작과 재시도가 겹치는 작업에서는 이 세 관점을 함께 검토해야 한다.

이 글은 학습 노트에서 정리한 정의·증상·방어 기법을 설명하는 개념 정리다. 주문이나 영상 인코딩 파이프라인은 개념을 설명하기 위한 가상 상황이며, 코드는 실제 장애 기록이나 실행 결과가 아닌 합성 의사코드다. 예를 들어 작업이 중간에 멈춘 뒤 앞 단계를 다시 실행하면 부작용이 중복될 수 있고, 여러 워커가 동시에 재개하면 갱신 충돌도 생길 수 있다. 각 방어가 어느 문제를 맡는지 구분하며 읽으면 된다.

Race Condition: 공유 상태를 둘러싼 경쟁

정의

학습 노트에서 정리한 경쟁 상태(Race Condition)는 둘 이상의 실행 흐름이 공유 상태에 동시에 접근할 때 실행 순서와 타이밍에 따라 결과가 달라지는 비결정적 버그다. 실행 흐름에는 스레드, 프로세스, 워커, 이벤트 핸들러가 포함된다. 같은 코드와 입력이라도 스케줄링이 다르게 겹칠 수 있어 재현이 어렵다. 로컬 테스트에서는 통과하다가 프로덕션 부하에서 드러나는 상황도 이 차이로 설명할 수 있다.

증상과 예시

두 스레드가 같은 잔액을 읽고 각각 계산한 뒤 차례로 써서 먼저 반영된 갱신이 사라지는 Lost Update 다이어그램
읽기·계산·쓰기가 겹치면서 먼저 반영된 갱신이 사라지는 Lost Update의 개념도.
  • stale write wins(지연 도착이 최신 상태를 덮어씀): 최신 이벤트를 처리한 뒤 늦게 도착한 과거 이벤트가 예전 값을 다시 쓴다. 잔액이나 재고 수치가 시간상 되돌아가는 것처럼 보일 수 있다.
  • lost update(갱신 유실): 값을 읽고 계산하고 쓰는 사이에 다른 실행 흐름이 끼어들어 한쪽의 갱신이 사라진다. 잔액 차감 예시에서는 먼저 반영한 차감이 나중 쓰기에 덮인다.
  • 교착 상태(deadlock): 두 실행 흐름이 서로 다른 순서로 락을 요청해 영구 대기에 빠진다. 엄밀히는 별개 범주지만 공유 상태 동시 접근 문제군에서 함께 다룬다.

다음은 두 워커가 계좌 잔액을 동시에 차감하는 합성 예시다. 두 워커가 같은 잔액을 읽은 뒤 각자 계산한 값을 쓰면 나중 쓰기가 앞선 갱신을 덮는다. 문제는 차감 계산 하나가 아니라 읽기와 쓰기 사이에 다른 워커가 들어올 수 있다는 점이다.

// 버그: read-modify-write 사이에 다른 워커가 끼어들 수 있다
function withdraw(accountId, amount) {
  balance = db.read(accountId)          // 워커 A, B 모두 1000을 읽음
  if (balance < amount) {
    throw new Error("insufficient funds")
  }
  newBalance = balance - amount         // A: 1000-300=700, B: 1000-500=500
  db.write(accountId, newBalance)       // 나중 쓰기가 앞선 차감을 덮음
}

방어 기법

두 워커가 버전 1을 읽은 뒤 먼저 버전 2로 갱신한 결과와 충돌한 쓰기를 거절하고 재조회해 버전 3으로 반영하는 다이어그램
현재 버전과 맞지 않는 쓰기를 거절하고 최신 상태를 다시 읽어 재시도하는 낙관적 동시성 제어.
  • 단조 증가 버전 번호: 상태에 revision을 두고 오래된 갱신을 구분한다. 읽은 버전을 기준으로 갱신을 허용하는 낙관적 동시성 제어에도 버전을 사용한다.
  • 버전 벡터(version vector, vector clock): 여러 노드가 독립적으로 갱신하는 환경에서 노드별 카운터로 인과 순서를 추적한다. 충돌과 단순 선후 관계를 구분하기 위한 방법이다.
  • 비교 후 교체(compare-and-swap, CAS): 기대한 값이나 버전이 현재 상태와 일치할 때만 갱신하는 판단과 쓰기를 원자적으로 수행한다.
  • 락 / 트랜잭션 격리 수준: 공유 상태에 접근하는 임계 영역을 보호한다. 노트는 넓은 락 범위의 처리량과 교착 상태 문제를 함께 검토하고 버전 비교 방식도 고려하도록 정리한다.

같은 차감 예시를 CAS로 방어하면 아래처럼 된다. 잔액을 읽은 뒤 다른 워커가 버전을 바꾸었다면 쓰기가 실패한다. 호출자는 최신 잔액과 버전을 다시 읽어 차감 가능 여부부터 확인한다.

// 방어: 버전 비교로 충돌을 감지하고 재시도
function withdraw(accountId, amount) {
  while (true) {
    { balance, version } = db.read(accountId)
    if (balance < amount) {
      throw new Error("insufficient funds")
    }
    newBalance = balance - amount

    // version이 그대로일 때만 갱신 (compare-and-swap)
    updated = db.compareAndSwap(accountId, {
      expectedVersion: version,
      newBalance: newBalance,
      newVersion: version + 1
    })

    if (updated) return newBalance
    // 다른 워커가 먼저 갱신했다면 최신 상태로 재시도
  }
}

Partial Write: 중간에 끊기는 다단계 작업

정의

학습 노트에서 정리한 부분 쓰기(Partial Write)는 다단계 쓰기 작업이 중간에 실패해 일부만 반영된 상태로 남는 문제다. 원인에는 프로세스 크래시, 워커 강제 종료, 네트워크 단절, 타임아웃 등이 있다. 여러 외부 API를 순서대로 호출하는 작업처럼 단일 트랜잭션으로 전체 성공이나 전체 실패를 묶기 어려운 상황에서 고려해야 한다.

증상과 예시

체크포인트 없이 재시작해 이미 완료한 단계가 중복 실행되는 과정을 보여주는 다이어그램
이미 완료한 단계를 구분하지 않고 처음부터 재실행하는 가상 상황.
  • 재시작 시 중복 부작용: 완료된 앞 단계를 다시 실행하면서 과금, 알림 발송, 리소스 생성이 중복될 수 있다.
  • 어중간한 상태로 정지: 재개 로직이 없으면 작업이 중간 상태에 남는다. 가상 주문에서는 결제 완료와 배송 준비 사이에 멈춘 상태를 생각할 수 있다.
  • 부분 커밋으로 인한 데이터 불일치: 관련 레코드 중 일부만 갱신돼 참조 무결성이 깨지거나 후속 소비자가 불완전한 데이터를 읽을 수 있다.

영상 인코딩을 예로 들면 과금, 인코딩, 알림을 순서대로 실행할 수 있다. 알림 단계에서 중단된 뒤 처음부터 재실행하면 앞서 끝난 과금도 다시 호출된다. 아래 코드는 이 문제를 드러내기 위한 예시다.

// 버그: 중간 실패 뒤 처음부터 재실행하면 완료된 단계도 다시 호출된다
async function encodeVideo(jobId) {
  await chargeCustomer(jobId)          // 1단계: 과금
  await transcodeSegments(jobId)       // 2단계: 인코딩
  await notifyUser(jobId)              // 3단계: 알림 발송 (여기서 크래시)
  await markDone(jobId)
}
// 재시작 후 encodeVideo(jobId)를 다시 호출하면 과금 단계도 다시 실행한다

방어 기법

  • 원자적 단위로 분해(chunking): 전체 작업을 재시도 가능한 단위로 나눈다. 각 단위는 자체적으로 성공과 실패를 판정할 수 있어야 한다.
  • 증분 체크포인트(incremental checkpoint): 각 단위가 끝날 때 완료 사실을 영속 저장소에 기록한다. 재개할 때는 완료된 단위를 건너뛴다.
  • 완료 판정과 실제 산출물을 함께 검증: 체크포인트의 완료 표시뿐 아니라 파일이나 레코드 같은 실제 산출물도 확인한다. 체크포인트 기록과 부작용 사이에도 부분 쓰기가 생길 수 있기 때문이다.
  • 작업 단위의 순서 독립성 확보: 가능한 단위는 독립적으로 재실행할 수 있도록 설계한다.
완료된 1단계와 2단계는 체크포인트와 실제 산출물을 확인해 건너뛰고 미완료 3단계부터 재개하는 다이어그램
완료 기록과 실제 산출물을 함께 확인해 재개 지점을 정하는 예시.
// 방어: 단계마다 체크포인트를 남기고 실제 산출물도 확인한다
async function encodeVideo(jobId) {
  const checkpoint = await loadCheckpoint(jobId)

  if (!(await isStageDone(jobId, STAGE.CHARGED, checkpoint))) {
    await chargeCustomer(jobId)
    await saveCheckpoint(jobId, STAGE.CHARGED)
  }
  if (!(await isStageDone(jobId, STAGE.TRANSCODED, checkpoint))) {
    await transcodeSegments(jobId)
    await saveCheckpoint(jobId, STAGE.TRANSCODED)
  }
  if (!(await isStageDone(jobId, STAGE.NOTIFIED, checkpoint))) {
    await notifyUser(jobId)
    await saveCheckpoint(jobId, STAGE.NOTIFIED)
  }
  await markDone(jobId)
}

async function isStageDone(jobId, stageId, checkpoint) {
  const artifact = await fetchArtifact(jobId, stageId)
  if (artifact) {
    if (checkpoint.stage < stageId) {
      // 산출물은 있는데 완료 기록이 뒤처졌다면 기록을 보정한다
      await saveCheckpoint(jobId, stageId)
    }
    return true
  }
  if (checkpoint.stage >= stageId) {
    // 기록과 산출물이 어긋나면 완료로 간주하지 않는다
    throw new Error("checkpoint and artifact mismatch")
  }
  return false
}

이 예시에서도 체크포인트만으로 중복 부작용을 막지는 못한다. 과금은 성공했는데 체크포인트를 남기지 못했다면 재개 과정에서 과금 함수를 다시 호출할 수 있다. 그 함수가 같은 작업의 반복 호출을 어떻게 처리하는지도 정해야 한다. 이 계약이 다음 절의 멱등성이다.

Idempotency: 재시도를 안전하게 만드는 계약

정의

학습 노트에서 정리한 멱등성(Idempotency)은 같은 요청이나 작업을 한 번 수행하든 반복 수행하든 관측 가능한 결과와 부작용이 같아야 한다는 성질이다. 수학의 멱등 연산은 f(f(x)) = f(x)로 표현한다. 분산 시스템에서는 같은 요청이 여러 번 도착해도 실제 효과가 한 번 수행한 것과 같도록 만드는 계약으로 읽을 수 있다.

증상과 예시: 멱등성이 없을 때

  • 재시도 로직에서의 부작용 중복: 응답을 받기 전에 타임아웃이 나더라도 서버는 요청을 이미 처리했을 수 있다. 같은 요청을 다시 보내면 과금이나 리소스 생성, 알림 발송이 중복될 수 있다.
  • 최소 1회(at-least-once) 전달에서의 중복 수신: 같은 메시지가 다시 전달될 수 있으므로 소비자가 반복 처리를 어떻게 다룰지 정해야 한다.

결제 API의 가상 상황에서는 첫 요청의 응답만 유실될 수 있다. 클라이언트가 이를 실패로 판단해 다시 호출해도 첫 결제가 취소됐다는 뜻은 아니다. 아래 코드는 재시도 요청을 구분할 수단이 없는 경우다.

첫 결제 응답이 유실된 뒤 같은 요청을 재시도해 결제가 두 번 승인되는 과정을 보여주는 다이어그램
응답 유실 뒤 같은 결제를 다시 실행하는 가상 상황.
// 버그: 같은 작업의 재시도를 구분하지 않는다
async function charge(cardToken, amountCents) {
  const result = await paymentGateway.charge(cardToken, amountCents)
  return result
}
// 응답 타임아웃 뒤 재호출해도 첫 요청은 이미 성공했을 수 있다

방어 기법

  • 완료 마커 / sentinel: 요청이나 작업 단위에 고유 키를 두고 완료 사실을 영속 저장소에 기록한다.
  • 재시도 시 sentinel 우선 확인: 완료 표시가 있으면 실제 로직을 다시 실행하지 않고 저장한 결과를 반환한다.
  • idempotency key 패턴: 클라이언트가 같은 작업의 요청에 같은 키를 보내고 서버는 그 키로 처리 이력을 구분한다.
  • 자연히 멱등적인 연산 설계: 같은 값을 반복해서 더하는 연산과 정해진 최종값으로 설정하는 연산의 차이를 검토한다. 레코드를 반복 추가하는 대신 키를 기준으로 없으면 추가하는 방식도 고려할 수 있다.
같은 idempotency key의 요청을 pending 상태로 예약하고 완료 결과를 저장해 재시도 때 게이트웨이를 다시 호출하지 않는 다이어그램
같은 키를 원자적으로 예약하고 완료 결과를 저장해 재사용하는 설계 예시.
// 방어: 조회 후 실행하기 전에 같은 키를 원자적으로 예약한다
async function charge(idempotencyKey, cardToken, amountCents) {
  let record
  try {
    // idempotencyKey의 UNIQUE 제약으로 동시 예약을 가른다
    record = await db.insertPendingRecord(idempotencyKey, { status: "PENDING" })
  } catch (err) {
    if (err.code === "UNIQUE_VIOLATION") {
      return await waitForCompletion(idempotencyKey)
    }
    throw err
  }

  if (record.status === "COMPLETED") {
    return record.result
  }

  // 외부 부작용에도 같은 키의 멱등성 계약이 필요하다
  const result = await paymentGateway.charge(cardToken, amountCents, {
    idempotencyKey
  })

  // 로컬 결과 저장과 상태 전이를 함께 반영한다
  await db.transaction(async (tx) => {
    await tx.completeRecord(idempotencyKey, {
      expectedStatus: "PENDING",
      newStatus: "COMPLETED",
      result
    })
  })

  return result
}

먼저 조회하고 나중에 완료 기록을 저장하는 순서만으로는 동시 요청을 막을 수 없다. 두 요청이 조회를 함께 통과할 수 있기 때문에 위 예시는 고유 제약으로 먼저 예약한다. 다만 외부 호출과 로컬 기록 사이의 부분 쓰기는 여전히 고려해야 한다. 위 코드는 예약과 완료 저장의 위치를 보여주며, 중단된 작업의 재개까지 보장하는 완성 구현은 아니다.

세 가지를 함께 방어하는 법

체크포인트가 있어도 재개 로직이 멱등적이지 않으면 반복 실행의 부작용이 남는다. 멱등성 키는 중복 효과를 다루지만 어느 단계까지 완료했는지를 기록하는 역할과는 다르다. 여러 워커가 같은 작업을 재개하면 공유 상태의 갱신 충돌도 검토해야 한다. 학습 노트는 중단 뒤 재개하는 워크플로우에 다음 계층을 함께 두는 기준으로 정리한다.

  • 체크포인트: 완료한 단위를 영속적으로 기록하고 산출물과 대조해 재개 위치를 정한다.
  • 멱등성 키: 같은 단계의 반복 실행이 부작용 중복으로 이어지지 않도록 계약을 정한다.
  • 동시성 제어: 버전 비교, 락, CAS, 트랜잭션 등으로 공유 상태의 경쟁을 다룬다.

재개 위치, 반복 실행의 효과, 동시 갱신의 충돌은 서로 다른 질문이므로 함께 확인한다.

아래 합성 의사코드는 세 계층이 들어갈 위치를 보여준다. CAS는 같은 버전을 읽은 워커들의 갱신 충돌을 감지한다. 각 단계의 외부 부작용에는 별도의 멱등성 계약이 필요하며, 결과와 체크포인트는 함께 기록한다. 버전 비교 한 번만으로 작업 전체의 독점 실행이나 모든 중단 상황의 복구까지 보장한다고 읽어서는 안 된다.

// 체크포인트 + 멱등성 키 + 버전 비교를 배치한 합성 예시
async function resumeJob(jobId, workerId) {
  const { checkpoint, version } = await db.read(jobId)

  // 같은 버전에서 출발한 갱신 충돌을 감지한다
  const claimed = await db.compareAndSwap(jobId, {
    expectedVersion: version,
    newOwner: workerId,
    newVersion: version + 1
  })
  if (!claimed) {
    return
  }

  for (const stage of remainingStages(checkpoint)) {
    const idempotencyKey = `${jobId}:${stage.name}`
    await runStageIdempotently(jobId, idempotencyKey, stage)
  }

  await markDone(jobId)
}

async function runStageIdempotently(jobId, idempotencyKey, stage) {
  const existing = await db.findByIdempotencyKey(idempotencyKey)
  if (existing?.status === "COMPLETED") {
    return existing.result
  }

  // stage.run 자체가 같은 키의 반복 호출을 처리하는 계약을 전제로 한다
  const result = await stage.run(jobId, { idempotencyKey })

  // 로컬 결과 기록과 체크포인트 갱신을 함께 커밋한다
  // 외부 부작용은 이 트랜잭션에 포함되지 않는다
  await db.transaction(async (tx) => {
    await tx.saveIdempotencyRecord(idempotencyKey, { status: "COMPLETED", result })
    await saveCheckpoint(tx, jobId, stage.name)
  })

  return result
}

async function saveCheckpoint(tx, jobId, stageName) {
  const { version } = await tx.read(jobId)
  const updated = await tx.compareAndSwap(jobId, {
    expectedVersion: version,
    newStage: stageName,
    newVersion: version + 1
  })
  if (!updated) {
    throw new Error(`checkpoint version conflict: ${jobId} at stage ${stageName}`)
  }
}

재시도·재시작 로직을 읽을 때는 완료 상태가 어디에 남는지부터 확인할 수 있다. 그다음 같은 단계가 반복돼도 되는지, 여러 실행 흐름이 같은 상태를 바꾸면 어떻게 충돌을 가리는지 살핀다. 이 구분을 기준으로 코드를 보면 재시도 하나나 락 하나에 서로 다른 책임을 맡기고 있는지 검토할 수 있다. 관련 개발 주제는 프로그래밍 카테고리에서 찾아볼 수 있다.

자주 묻는 질문

체크포인트가 완료라고 표시하면 실제 산출물 확인은 생략해도 되나요?

생략하면 안 된다. 체크포인트 기록과 실제 부작용 사이에서도 부분 쓰기가 생길 수 있다. 완료 표시와 파일·레코드 같은 실제 산출물을 함께 확인하고, 둘이 어긋나면 기록을 보정한 뒤 재실행 여부를 정해야 한다.

idempotency key를 조회한 뒤 처리하고 결과를 저장하면 동시 요청도 안전한가요?

아니다. 두 요청이 조회를 동시에 통과할 수 있다. 고유 제약으로 PENDING 레코드를 원자적으로 예약하고, 프로바이더에도 같은 키를 전달하며, 결과 저장과 상태 전이를 트랜잭션이나 조건부 갱신으로 묶어야 한다.

체크포인트와 멱등성만 있으면 여러 워커의 동시 재개도 막을 수 있나요?

부족하다. 체크포인트는 재개 위치를, 멱등성 키는 반복 실행의 효과를 다루지만 여러 워커가 공유 상태를 동시에 갱신하는 경쟁은 남는다. 버전 비교나 락 같은 동시성 제어를 함께 설계해야 한다.