Folly Code Review · 86/89

folly::CancellationToken — 코루틴·Future 취소 전파

2026년 6월 8일 · Hawk · 4분 읽기

한 줄 요약: CancellationToken은 코루틴·Future 트리에 협력적 취소를 전파한다. C++26 senders/receivers의 stop_token과 등가 모델로 Meta가 일찍 도입했다.

#동기

긴 비동기 작업이 외부 조건 (timeout, user cancel, parent failed)으로 멈춰야 할 때가 있다. callback-style code는 일반적으로 다음 둘 중 하나.

boolean flag — 작업 시작 전 매번 체크. 누락 시 무한 hang.
exception — 강제 unwind. 자원 leak/일관성 문제.

CancellationToken은 셋째 길이다. 명시적이고 합성 가능한 cancellation 신호.

1
folly::CancellationSource src;
2
auto token = src.getToken();
3

4
// 어딘가에서 cancel
5
src.requestCancellation();
6

7
// 토큰을 받은 쪽은 chunks마다 check 또는 await 자체가 cancel-aware
8
if (token.isCancellationRequested()) {
9
  return;
10
}

이 모델은 cooperative. cancel 요청은 신호일 뿐, 실제로 멈추는 건 작업이 체크해서 결정.

#API

1
namespace folly {
2

3
class CancellationSource {
4
 public:
5
  CancellationSource();
6
  bool requestCancellation() noexcept;   // 한 번만 효력
7
  CancellationToken getToken() const noexcept;
8
};
9

10
class CancellationToken {
11
 public:
12
  bool isCancellationRequested() const noexcept;
13
  bool canBeCancelled() const noexcept;
14
  CancellationCallback addCallback(/* func */);   // cancel 시 호출
15
};
16

17
class CancellationCallback {
18
  // RAII — destructor에서 unregister
19
};
20

21
}

세 클래스가 한 세트.

CancellationSource — 소유자. cancel을 발행.
CancellationToken — 소비자. cancel 여부를 조회.
CancellationCallback — token이 cancel될 때 호출되는 callback. RAII로 자동 unregister.

#Coroutine 통합

1
folly::coro::Task<int> LongCompute(folly::CancellationToken ct) {
2
  for (int i = 0; i < 1000000; ++i) {
3
    if (i % 1000 == 0 && ct.isCancellationRequested()) {
4
      throw folly::OperationCancelled{};
5
    }
6
    // compute step
7
  }
8
  co_return 42;
9
}
10

11
folly::coro::Task<int> WithCancellation() {
12
  folly::CancellationSource src;
13

14
  std::thread([src]() mutable {
15
    std::this_thread::sleep_for(std::chrono::seconds(5));
16
    src.requestCancellation();
17
  }).detach();
18

19
  co_return co_await folly::coro::co_withCancellation(
20
    src.getToken(), LongCompute(src.getToken()));
21
}

co_withCancellation이 token을 코루틴 frame에 attach. cancel-aware awaitable은 자동으로 깨어남.

#co_current_cancellation_token

1
folly::coro::Task<int> Helper() {
2
  auto token = co_await folly::coro::co_current_cancellation_token;
3
  if (token.isCancellationRequested()) {
4
    throw folly::OperationCancelled{};
5
  }
6
  // ...
7
}

코루틴은 호출 트리에서 token을 상속한다. parent가 cancel되면 child도 cancel 신호를 받음.

#CancellationCallback — 동기적 cleanup

1
folly::coro::Task<void> ReadWithCleanup(int fd) {
2
  auto token = co_await folly::coro::co_current_cancellation_token;
3

4
  folly::CancellationCallback cb{token, [fd]() {
5
    // cancel 시 호출 — fd close해서 read syscall 깨움
6
    ::shutdown(fd, SHUT_RDWR);
7
  }};
8

9
  // 이 read가 cancel signal을 직접 못 받음 (blocking)
10
  auto bytes = co_await asyncRead(fd, buf, len);
11
  co_return;
12
}

CancellationCallback이 token cancellation 시 동기적으로 호출된다. 이걸로 blocking syscall을 깨우는 트릭. socket shutdown, file close 같은 자리.

#트리 전파

CancellationToken tree propagation

1
folly::CancellationSource root;
2
auto rootToken = root.getToken();
3

4
folly::coro::Task<void> Parent() {
5
  co_await folly::coro::co_withCancellation(
6
    rootToken,
7
    folly::coro::collectAll(
8
      ChildA(),   // 자동으로 rootToken 상속
9
      ChildB(),   // 자동으로 rootToken 상속
10
      ChildC()    // 자동으로 rootToken 상속
11
    ));
12
}

co_withCancellation이 한 번 attach하면 child Task들은 자동으로 같은 token을 본다. root가 cancel되면 셋 다 신호 받음. timer wheel, RPC fan-out 같은 패턴에 자연스럽다.

#MergeCancellationToken

1
auto merged = folly::cancellation_token_merge(token1, token2);
2
// merged는 두 token 중 하나라도 cancel되면 cancel

여러 cancel 조건을 OR 합성. timeout + user cancel을 동시에 표현.

#내부 구조

1
// folly/CancellationToken.h 약식
2
class CancellationState {
3
  std::atomic<uint64_t> state_;   // bit 0 = cancel requested, 상위 bits = ref count
4
  std::list<CancellationCallback*> callbacks_;
5
  std::mutex mu_;
6
};
7

8
// CancellationSource owns + 1 ref, each Token + 1 ref
9
// state_ atomic CAS로 cancel 요청 atomic하게
10

11
bool CancellationSource::requestCancellation() {
12
  auto prev = state_->state_.fetch_or(kCancelBit);
13
  if (prev & kCancelBit) return false;   // 이미 cancel됨
14

15
  // callbacks 호출 (lock 보호)
16
  std::lock_guard lk(state_->mu_);
17
  for (auto* cb : state_->callbacks_) {
18
    cb->invoke();
19
  }
20
  return true;
21
}

핵심은 한 번만 cancel 가능 (atomic test-and-set), 그 시점에 모든 callback이 sync 호출.

#std::stop_token (C++20)과의 비교

항목	std::stop_token	folly::CancellationToken
도입	C++20	folly (수년 전)
Source/Token	stop_source / stop_token	CancellationSource / CancellationToken
Callback	stop_callback	CancellationCallback
Coroutine 통합	없음 (stdexec/P2300이 추가)	co_withCancellation
표준	std	folly

C++20 std::stop_token은 std::jthread의 멤버로 도입. 모델은 거의 동일. 차이는 코루틴 통합. stdexec/P2300이 표준 sender/receiver에 통합 중.

folly::CancellationToken은 std::stop_token과 형식적 일치 — 표준이 따라잡으면 마이그레이션 가능.

#코드 리뷰 포인트

긴 작업에 cancellation 체크 없음 → 외부 조건 변화 시 영원히 hang.
requestCancellation() 후 작업이 즉시 멈추리라고 가정 → cooperative라 작업이 check할 때 멈춤.
callback 안에서 무거운 작업 또는 lock 획득 → cancel 발행 thread를 block.
token을 ref로 전달하는데 source가 먼저 소멸 → callback 호출 시점에 dangling 가능 (folly 구현은 shared state로 보호).
nested cancellation — child가 자체 source를 만들면 root cancel이 child까지 전파 안 됨. 명시적 attach.

#자주 보는 안티패턴

1
// 1. cancellation 무시
2
folly::coro::Task<int> Naive() {
3
  for (int i = 0; i < 1e9; ++i) compute();   // cancel 체크 없음
4
  co_return 0;
5
}
6

7
// 2. callback이 무거운 작업
8
folly::CancellationCallback cb{token, [&] {
9
  ProcessHugeBuffer();   // cancel 발행 thread를 block
10
}};
11

12
// 3. token을 cancel-naive awaitable에 전달
13
co_await blockingRead(fd, buf, len);   // ct가 있지만 read는 무관
14

15
// 4. exception 던지지 않고 silent return
16
if (ct.isCancellationRequested()) {
17
  co_return -1;   // 호출자가 cancel인지 fail인지 모름
18
}
19
// → folly::OperationCancelled throw가 표준 패턴

#실전 — RPC client timeout

1
folly::coro::Task<Response> CallRpc(Request req, std::chrono::milliseconds timeout) {
2
  folly::CancellationSource src;
3

4
  // timer가 cancel 발행
5
  auto timer = std::thread([src, timeout]() mutable {
6
    std::this_thread::sleep_for(timeout);
7
    src.requestCancellation();
8
  });
9

10
  try {
11
    auto result = co_await folly::coro::co_withCancellation(
12
      src.getToken(), client_->send(std::move(req)));
13
    timer.detach();   // 정상 완료 — timer 무시
14
    co_return result;
15
  } catch (const folly::OperationCancelled&) {
16
    timer.detach();
17
    throw RpcTimeoutException{};
18
  }
19
}