absl::Mutex — reader-writer·fairness·deadlock 검출

1
#include "absl/synchronization/mutex.h"
2

3
absl::Mutex mu;
4

5
// exclusive
6
mu.Lock();
7
// ...
8
mu.Unlock();
9

10
// RAII
11
{
12
  absl::MutexLock lock(&mu);
13
  // ...
14
}
15

16
// shared (read)
17
mu.ReaderLock();
18
mu.ReaderUnlock();
19

20
// 또는
21
{
22
  absl::ReaderMutexLock lock(&mu);
23
  // ...
24
}

1
class Queue {
2
 public:
3
  void Push(int x) {
4
    absl::MutexLock l(&mu_);
5
    items_.push_back(x);
6
  }
7

8
  int PopWaiting() {
9
    absl::MutexLock l(&mu_);
10
    mu_.Await(absl::Condition(this, &Queue::HasItem));
11
    int x = items_.front();
12
    items_.pop_front();
13
    return x;
14
  }
15

16
 private:
17
  bool HasItem() const ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_) {
18
    return !items_.empty();
19
  }
20

21
  absl::Mutex mu_;
22
  std::deque<int> items_ ABSL_GUARDED_BY(mu_);
23
};

1
// std — condition variable 관용구
2
std::mutex mu;
3
std::condition_variable cv;
4
std::deque<int> q;
5

6
void Push(int x) {
7
  {
8
    std::lock_guard<std::mutex> l(mu);
9
    q.push_back(x);
10
  }
11
  cv.notify_one();
12
}
13

14
int Pop() {
15
  std::unique_lock<std::mutex> l(mu);
16
  cv.wait(l, [&] { return !q.empty(); });   // predicate while loop
17
  int x = q.front(); q.pop_front();
18
  return x;
19
}

1
// absl — Await로 같은 동작
2
absl::Mutex mu;
3
std::deque<int> q;
4

5
void Push(int x) {
6
  absl::MutexLock l(&mu);
7
  q.push_back(x);
8
  // notify 불필요 — Await가 자동
9
}
10

11
int Pop() {
12
  absl::MutexLock l(&mu);
13
  mu.Await(absl::Condition(+[](std::deque<int>* q) {
14
    return !q->empty();
15
  }, &q));
16
  int x = q.front(); q.pop_front();
17
  return x;
18
}

1
class Cache {
2
 public:
3
  std::string Get(absl::string_view key) ABSL_LOCKS_EXCLUDED(mu_);
4

5
 private:
6
  std::string LookupLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mu_);
7

8
  absl::Mutex mu_;
9
  absl::flat_hash_map<std::string, std::string> data_ ABSL_GUARDED_BY(mu_);
10
};

1
ASSERTION FAILED: lock cycle detected:
2
  thread T1: acquired mu_a then waited on mu_b
3
  thread T2: acquired mu_b then waited on mu_a

1
absl::RegisterMutexProfiler(&MyProfiler);
2
// MyProfiler가 매 contention 이벤트에서 호출됨

1
// 회피 — notify 누락, spurious wakeup 함정
2
std::mutex mu;
3
std::condition_variable cv;
4
bool ready = false;
5

6
// producer
7
{
8
  std::lock_guard<std::mutex> l(mu);
9
  ready = true;
10
}
11
cv.notify_one();   // ← 누락하면 deadlock
12

13
// consumer
14
std::unique_lock<std::mutex> l(mu);
15
cv.wait(l, [&] { return ready; });

1
// Good
2
absl::Mutex mu;
3
bool ready = false;
4

5
// producer
6
{
7
  absl::MutexLock l(&mu);
8
  ready = true;
9
  // notify 불필요
10
}
11

12
// consumer
13
absl::MutexLock l(&mu);
14
mu.Await(absl::Condition(&ready));

1
class ConfigCache {
2
 public:
3
  std::string Get(absl::string_view key) {
4
    absl::ReaderMutexLock l(&mu_);
5
    auto it = data_.find(key);
6
    return it == data_.end() ? "" : it->second;
7
  }
8

9
  void Set(std::string k, std::string v) {
10
    absl::MutexLock l(&mu_);
11
    data_[std::move(k)] = std::move(v);
12
  }
13

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

1
// 회피 — 임시 객체가 즉시 소멸, lock 해제됨
2
absl::MutexLock(&mu_);  // 변수 이름 없음
3
DoWork();                // unlocked

1
// Good
2
absl::MutexLock l(&mu_);
3
DoWork();

1
mu_.Await(absl::Condition([&] {
2
  other_mu_.Lock();    // 회피 — Await predicate 안에서 다른 lock
3
  // ...
4
}));