Folly Code Review · 7/89

folly::Promise·makeFuture — Future를 만드는 두 길

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

한 줄 요약: Promise<T>는 나중에 값/예외를 채우는 생산자 측 핸들이고, makeFuture 계열은 이미 결정된 값을 Future 인터페이스에 올리는 단축 길이다.

#동기 — 왜 두 가지 길이 필요한가

비동기 계산의 결과를 Future로 표현할 때 두 가지 상황이 있다.

결과가 아직 없음 — I/O 완료, timer 발화, 다른 thread의 작업 종료 등을 기다림
결과가 이미 있음 — 캐시 hit, validation 실패로 즉시 실패, default 값 반환

(1)은 Promise<T>로 표현한다. 생산자는 Promise를 들고 있다가 결과가 나오면 setValue()를 호출한다. (2)는 makeFuture(value) / makeSemiFuture(value)로 표현한다. 새 Promise를 만들고 즉시 set하는 한 줄짜리 단축이다.

두 길의 결과물은 같다. 동일한 Core<T>를 가리키는 Future/SemiFuture가 만들어진다.

#Promise — 생산자 측 핸들

1
#include <folly/futures/Promise.h>
2
#include <folly/futures/Future.h>
3

4
folly::Promise<int> p;
5
folly::SemiFuture<int> sf = p.getSemiFuture();
6

7
// 다른 thread에서
8
std::thread([p = std::move(p)]() mutable {
9
  std::this_thread::sleep_for(std::chrono::seconds(1));
10
  p.setValue(42);
11
}).detach();
12

13
int v = std::move(sf).via(&inlineExecutor).get();   // 42

Promise는 한 번만 set할 수 있다. 두 번 set하면 PromiseAlreadySatisfied 예외가 throw된다.

1
// folly/futures/Promise.h (요약)
2
template <class T>
3
class Promise {
4
 public:
5
  Promise() : Promise(makeEmptyConstruct()) {
6
    core_ = new detail::Core<T>();
7
  }
8

9
  void setValue(T&& v) {
10
    throwIfFulfilled();
11
    core_->setResult(Try<T>(std::move(v)));
12
  }
13

14
  void setException(exception_wrapper ew) {
15
    throwIfFulfilled();
16
    core_->setResult(Try<T>(std::move(ew)));
17
  }
18

19
  template <class F>
20
  void setWith(F&& fn) {
21
    throwIfFulfilled();
22
    core_->setResult(makeTryWith(std::forward<F>(fn)));
23
  }
24

25
  SemiFuture<T> getSemiFuture();   // 한 번만 호출 가능
26
  Future<T> getFuture();            // SemiFuture + InlineExecutor
27

28
 private:
29
  detail::Core<T>* core_;
30
};

setWith()는 함수 호출이 throw할 수 있을 때 편리하다.

1
folly::Promise<int> p;
2
p.setWith([] { return mayThrow(); });
3
// throw하면 자동으로 setException로 변환

#makeFuture / makeSemiFuture

이미 결정된 값을 Future로 wrap한다.

1
folly::SemiFuture<int> ok = folly::makeSemiFuture(42);
2
folly::SemiFuture<int> ng = folly::makeSemiFuture<int>(
3
    folly::make_exception_wrapper<std::runtime_error>("bad"));
4

5
// void Future
6
folly::SemiFuture<folly::Unit> done = folly::makeSemiFuture();

Unit은 void를 1급 타입으로 다루기 위한 sentinel이다. Future<void>는 표준에 있지만 generic 코드에서 다루기 불편해 Folly는 Future<Unit>을 선호한다.

1
// folly/futures/Future.h (요약)
2
template <class T>
3
SemiFuture<typename std::decay_t<T>> makeSemiFuture(T&& t) {
4
  return SemiFuture<...>(Try<...>(std::forward<T>(t)));
5
}
6

7
template <class T>
8
SemiFuture<T> makeSemiFuture(Try<T> t) {
9
  return SemiFuture<T>(std::move(t));
10
}
11

12
SemiFuture<Unit> makeSemiFuture();   // void 대체

#Try — 값 또는 예외의 통합 컨테이너

Promise::setValue/setException은 내부적으로 Try<T>로 변환된다. Try<T>는 std::variant<T, exception_wrapper>에 가깝다.

1
// folly/Try.h (요약)
2
template <class T>
3
class Try {
4
 public:
5
  Try(T&& v);
6
  Try(exception_wrapper ew);
7

8
  bool hasValue() const;
9
  bool hasException() const;
10

11
  T& value() &;          // hasException이면 throw
12
  T&& value() &&;
13
  T const& operator*() const;
14
  T& operator*() &;
15
  T&& operator*() &&;
16

17
  exception_wrapper& exception();
18
};

Try<T>는 단순한 컨테이너지만, Future 체인 전체가 이 위에 돌아간다. 모든 .thenTry(callback)은 Try<T>를 인자로 받고 Try<R>을 반환한다.

1
folly::Future<int> f = folly::makeFuture(42)
2
  .thenTry([](folly::Try<int> t) -> int {
3
    if (t.hasException()) return -1;
4
    return *t * 2;
5
  });

#makePromiseContract — 쌍을 한 번에

1
auto [p, sf] = folly::makePromiseContract<int>();
2
// p: Promise<int>
3
// sf: SemiFuture<int> — p와 같은 Core 공유

C++17 structured binding으로 깔끔하게 표현된다. Promise와 Future를 별도로 만들어 연결할 때 보일러플레이트를 줄인다.

1
// folly/futures/Promise.h (요약)
2
template <class T>
3
std::pair<Promise<T>, SemiFuture<T>> makePromiseContract() {
4
  auto p = Promise<T>();
5
  auto sf = p.getSemiFuture();
6
  return {std::move(p), std::move(sf)};
7
}

#std::promise와의 차이

1
// std::promise
2
std::promise<int> p;
3
std::future<int> f = p.get_future();
4
p.set_value(42);
5
int v = f.get();   // 42
6

7
// folly::Promise
8
folly::Promise<int> p;
9
folly::SemiFuture<int> sf = p.getSemiFuture();
10
p.setValue(42);
11
int v = std::move(sf).via(&inlineExecutor).get();   // 42

비슷해 보이지만 두 가지가 다르다.

continuation — std::promise의 future는 .then이 없다. f.get()만 가능.
exception API — std::promise::set_exception(std::exception_ptr)은 타입 정보를 잃는다. Promise::setException(exception_wrapper)은 타입을 보존한다.

exception_wrapper는 복사 가능한 exception 핸들로, type-erased 상태에서도 with_exception<E>()로 타입별 분기가 가능하다.

1
folly::exception_wrapper ew = folly::make_exception_wrapper<MyError>("bad");
2
if (ew.with_exception([](MyError& e) { handleMy(e); })) {
3
  // matched
4
}

#코드 리뷰 포인트

Promise의 수명이 Future보다 짧지 않은가? Promise가 먼저 파괴되면 BrokenPromise 예외로 Future가 완료된다. silent failure가 아닌 명시적 실패다.
getFuture() vs getSemiFuture()? 가능하면 후자를 쓴다. getFuture()는 InlineExecutor에 자동 바인딩되어 어디서 callback이 도는지 불명확하다.
Promise를 두 번 set하지는 않는가? thread 두 곳에서 set하면 둘 중 하나가 throw된다.
makeFuture에 큰 객체를 by value로 넘기지 않는가? makeFuture(std::move(x)) 또는 makeFuture<X>(args...) 사용.

#자주 보는 안티패턴

1
// 1. Promise를 lambda에서 capture by reference
2
folly::Promise<int> p;
3
auto f = p.getSemiFuture();
4
std::thread([&p]() { p.setValue(42); }).detach();
5
// p가 stack에서 사라지면 dangling — 반드시 std::move로 capture
6

7
// 2. Promise를 set한 뒤 다시 set
8
p.setValue(1);
9
p.setValue(2);   // throws PromiseAlreadySatisfied
10

11
// 3. getFuture()를 두 번
12
auto f1 = p.getFuture();
13
auto f2 = p.getFuture();   // throws FutureAlreadyRetrieved
14

15
// 4. setException(std::exception_ptr)
16
std::exception_ptr ep = std::make_exception_ptr(MyError{});
17
p.setException(folly::exception_wrapper(ep));
18
// 타입 정보가 흐려짐 — 가능하면 make_exception_wrapper<MyError>(...) 사용