Folly Code Review · 40/89

folly::Synchronized — lock wrapper 패턴

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

#한 줄 요약

folly::Synchronized<T>는 데이터 T와 lock을 묶어 lock 없이는 데이터 접근 자체가 불가하게 만든다. .wlock()/.rlock()로 RAII handle을 얻고, handle의 lifetime이 critical section.

#동기

mutex와 데이터를 별도 변수로 들고 있는 코드는 잠금 누락 버그가 잦다.

1
// 흔한 버그 패턴
2
std::mutex mu;
3
std::vector<int> data;
4

5
void Bad() {
6
  data.push_back(1);   // mu 안 잡음! race
7
}

리뷰로도 잡기 어렵다. 컴파일러가 강제하면 좋겠다. abseil의 Mutex annotation(GUARDED_BY)이 이런 문제를 해결하지만 clang 한정에 macro 식.

folly는 데이터를 mutex 안에 가둔다. 잠금 없이 데이터에 접근 자체가 안 되는 type.

1
folly::Synchronized<std::vector<int>> data;
2
data.wlock()->push_back(1);    // wlock 안에서만 가능

#lock 위에 올라간 비용을 시각화

Synchronized는 어떤 lock을 어디서 잡았는가를 명시할 뿐, contention 비용은 그대로다. 같은 critical section을 두고 여러 스레드가 다투면 직렬화된다.

Lock contention timeline

CS는 동시에 1 스레드만 들어간다. 짧은 CS, lock-free 자료구조, fine-grained lock으로 wait 영역을 줄이는 것이 핵심이다. folly::Synchronized의 통계 훅으로 wait time을 직접 측정할 수 있다.

#API & 사용법

1
#include <folly/Synchronized.h>
2

3
folly::Synchronized<std::vector<int>> data;
4

5
// 1. wlock — exclusive write
6
{
7
  auto locked = data.wlock();
8
  locked->push_back(1);
9
  locked->push_back(2);
10
}   // unlock
11

12
// 2. rlock — shared read (SharedMutex 사용 시)
13
{
14
  auto locked = data.rlock();
15
  size_t n = locked->size();
16
}
17

18
// 3. withWLock — 람다로 더 짧게
19
data.withWLock([](auto& v) {
20
  v.push_back(3);
21
});
22

23
// 4. withRLock
24
auto n = data.withRLock([](const auto& v) {
25
  return v.size();
26
});
27

28
// 5. SynchronizedPtr — 명시적 pointer-like
29
folly::Synchronized<int> n;
30
*n.wlock() = 42;
31

32
// 6. 직접 ctor에 args 전달
33
folly::Synchronized<std::string> s{"hello"};
34
folly::Synchronized<std::vector<int>, std::mutex> v;   // mutex type 선택

기본 mutex는 folly::SharedMutex(reader-writer). std::mutex, std::recursive_mutex 등도 template parameter로 지정 가능.

#내부 구현

Synchronized RAII lock guard

1
// 약식 — folly/Synchronized.h
2
template <class T, class Mutex = SharedMutex>
3
class Synchronized {
4
  mutable Mutex mu_;
5
  T             data_;
6

7
public:
8
  template <class... Args>
9
  Synchronized(Args&&... args) : data_(std::forward<Args>(args)...) {}
10

11
  auto wlock() {
12
    return LockedPtr<T, Mutex, LockMode::EXCLUSIVE>(this);
13
  }
14

15
  auto rlock() const {
16
    return LockedPtr<const T, Mutex, LockMode::SHARED>(this);
17
  }
18
};
19

20
template <class T, class Mutex, LockMode Mode>
21
class LockedPtr {
22
  Synchronized<T, Mutex>* parent_;
23
  // ctor에서 lock, dtor에서 unlock
24
public:
25
  LockedPtr(Synchronized<T, Mutex>* p) : parent_(p) {
26
    if constexpr (Mode == EXCLUSIVE) parent_->mu_.lock();
27
    else                              parent_->mu_.lock_shared();
28
  }
29
  ~LockedPtr() {
30
    if (parent_) {
31
      if constexpr (Mode == EXCLUSIVE) parent_->mu_.unlock();
32
      else                              parent_->mu_.unlock_shared();
33
    }
34
  }
35
  T* operator->() { return &parent_->data_; }
36
  T& operator*()  { return  parent_->data_; }
37
};

LockedPtr는 movable, copy 안 됨. operator->로 직접 멤버 접근. lifetime이 critical section을 정의.

#두 객체 동시 lock

1
folly::Synchronized<X> a;
2
folly::Synchronized<Y> b;
3

4
// 동시 lock — deadlock 방지 위해 항상 같은 순서
5
auto [la, lb] = folly::acquireLocked(a, b);
6
la->doX();
7
lb->doY();

acquireLocked는 deadlock 회피 알고리즘(주소 정렬 또는 try-lock 백오프) 사용. 직접 두 wlock 호출하면 다른 순서로 lock 잡힐 위험.

#std/abseil 비교

1
// std + 직접 작성
2
std::mutex mu;
3
std::vector<int> v;
4
{ std::lock_guard g(mu); v.push_back(1); }
5

6
// abseil — annotation 기반
7
ABSL_MUST_USE_RESULT absl::MutexLock l(&mu_);   // 잡지만 데이터 직접 보호 X
8
// 또는
9
class MyClass {
10
  absl::Mutex mu_;
11
  std::vector<int> v_ ABSL_GUARDED_BY(mu_);    // clang annotation
12
};
13

14
// folly
15
folly::Synchronized<std::vector<int>> v;
16
v.wlock()->push_back(1);

항목	std	absl annotation	folly::Synchronized
Lock 누락 검출	없음	clang annotation (warning)	컴파일 에러
API	외부 lock	외부 lock + annotation	데이터에 통합
Lock 종류	mutex만 외부 지정	외부	template parameter
두 lock 동시	std::lock	absl::WriterMutexLock	acquireLocked

folly의 강점: 컴파일 타임에 enforce. 데이터 접근 path가 lock acquire와 같은 expression.

#코드 리뷰 포인트

1
// Bad — LockedPtr를 다른 함수에 전달
2
void Helper(auto& locked_ptr) {  // mutex가 계속 잡힌 채로
3
  locked_ptr->Process();
4
}
5
data.withWLock([&](auto& v) {
6
  Helper(v);   // OK
7
});
8
auto l = data.wlock();
9
Helper(l);    // 위험 — lock 유효 시간이 모호해짐

LockedPtr는 wlock/rlock 호출과 같은 scope에서 즉시 사용. 다른 함수에 long-live로 넘기지 않는다.

1
// Bad — 중첩 lock
2
folly::Synchronized<X> a;
3
folly::Synchronized<Y> b;
4

5
void f() {
6
  auto la = a.wlock();
7
  auto lb = b.wlock();   // deadlock 가능 — 다른 thread가 b→a 순서면
8
}
9

10
// Good
11
void f() {
12
  auto [la, lb] = folly::acquireLocked(a, b);
13
  // ...
14
}

1
// Good — withWLock으로 critical section 명시
2
data.withWLock([](auto& v) {
3
  if (v.size() > kMax) v.resize(kMax);
4
  v.push_back(item);
5
});
6
// 람다 끝 = lock release. critical section 한눈에.

람다 폼이 가장 안전. lifetime을 람다 scope로 못박는다.

#안티패턴

*data.wlock()을 reference에 받기: auto& v = *data.wlock();는 LockedPtr가 즉시 destruct → lock 해제 → reference dangling. auto l = data.wlock(); auto& v = *l;처럼 LockedPtr 살리기.
wlock 안에서 외부 콜백 호출: blocking I/O가 lock을 끄지 않으면 다른 thread가 무한 대기. critical section은 짧게.
std::mutex 와 folly::Synchronized 혼용: 두 lock이 다른 객체에 걸리면 동시 lock 시 deadlock 회피 로직이 안 통한다. 한 가지로 통일.