absl::Mutex annotations — clang thread-safety로 race를 컴파일 타임에

1
#include "absl/base/thread_annotations.h"
2
#include "absl/synchronization/mutex.h"
3

4
class Cache {
5
 public:
6
  void Set(absl::string_view k, absl::string_view v)
7
      ABSL_LOCKS_EXCLUDED(mu_);
8
  std::string Get(absl::string_view k) const
9
      ABSL_LOCKS_EXCLUDED(mu_);
10

11
 private:
12
  std::string LookupLocked(absl::string_view k) const
13
      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
14

15
  mutable absl::Mutex mu_;
16
  absl::flat_hash_map<std::string, std::string> data_ ABSL_GUARDED_BY(mu_);
17
};
18

19
void Cache::Set(absl::string_view k, absl::string_view v) {
20
  absl::MutexLock l(&mu_);
21
  data_[std::string(k)] = std::string(v);   // OK — mu_ 보유
22
}
23

24
std::string Cache::Get(absl::string_view k) const {
25
  // 회피 — lock 없이 data_ 접근
26
  // return data_[std::string(k)];   // 경고: writing data_ requires holding mu_
27

28
  absl::MutexLock l(&mu_);
29
  return LookupLocked(k);   // OK — LookupLocked는 mu_ 요구, 우리가 보유
30
}
31

32
std::string Cache::LookupLocked(absl::string_view k) const {
33
  // mu_ 가 잡혀 있다고 가정 가능
34
  auto it = data_.find(k);
35
  return it == data_.end() ? "" : it->second;
36
}

1
void Cache::Refresh() ABSL_LOCKS_EXCLUDED(mu_) {
2
  // 외부에서 mu_ 잡지 않고 호출되어야 함
3
  absl::MutexLock l(&mu_);
4
  // ...
5
}
6

7
void OtherMethod() {
8
  absl::MutexLock l(&mu_);
9
  Refresh();   // 경고 — mu_ 보유 상태에서 LOCKS_EXCLUDED 함수 호출
10
}

1
class Config {
2
 public:
3
  std::string Get(absl::string_view k) const
4
      ABSL_SHARED_LOCKS_REQUIRED(mu_);   // reader lock만으로 충분
5

6
  void Set(absl::string_view k, absl::string_view v)
7
      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);   // writer lock 필요
8

9
 private:
10
  mutable absl::Mutex mu_;
11
  absl::flat_hash_map<std::string, std::string> data_ ABSL_GUARDED_BY(mu_);
12
};
13

14
// 호출 측
15
absl::ReaderMutexLock l(&cfg.mu_);
16
cfg.Get(...);   // OK
17
cfg.Set(...);   // 경고: EXCLUSIVE 요구

1
void TrickyHandler() ABSL_NO_THREAD_SAFETY_ANALYSIS {
2
  // 분석 비활성화
3
}

1
class Manager {
2
  absl::Mutex global_mu_;
3
  absl::Mutex local_mu_ ABSL_ACQUIRED_AFTER(global_mu_);
4
};

1
class Inbox {
2
  absl::Mutex mu_;
3
  std::deque<Msg> q_ ABSL_GUARDED_BY(mu_);
4
  size_t total_received_ ABSL_GUARDED_BY(mu_);   // 빼먹지 말 것
5
  size_t total_processed_ ABSL_GUARDED_BY(mu_);
6
};

1
class Manager {
2
  void DoWork(int x) ABSL_LOCKS_EXCLUDED(mu_);
3
 private:
4
  void DoWorkLocked(int x) ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
5
  absl::Mutex mu_;
6
};

1
void Process() {
2
  absl::MutexLock l(&mu_);
3
  callback_();   // 회피 — callback이 무엇을 하는지 모름, 다른 lock 잡으면 deadlock
4
}

1
// Thread safety: caller guarantees mu_ is held via shared_ptr binding.
2
void X() ABSL_NO_THREAD_SAFETY_ANALYSIS { ... }

1
class Foo {
2
 public:
3
  Bar* GetUnsafe() ABSL_LOCKS_EXCLUDED(mu_) {
4
    absl::MutexLock l(&mu_);
5
    return &bar_;   // 회피 — lock 밖으로 포인터 노출
6
  }
7
 private:
8
  absl::Mutex mu_;
9
  Bar bar_ ABSL_GUARDED_BY(mu_);
10
};