absl::Notification — once-only signal

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

3
namespace absl {
4
class Notification {
5
 public:
6
  Notification();
7
  bool HasBeenNotified() const;
8
  void WaitForNotification() const;
9
  bool WaitForNotificationWithTimeout(absl::Duration timeout) const;
10
  bool WaitForNotificationWithDeadline(absl::Time deadline) const;
11
  void Notify();
12
};
13
}

1
// 서버 초기화 패턴
2
class Server {
3
 public:
4
  void Start() {
5
    std::thread([this] {
6
      Initialize();
7
      ready_.Notify();   // 초기화 완료 알림
8
    }).detach();
9
  }
10

11
  void WaitReady() { ready_.WaitForNotification(); }
12
  bool IsReady() const { return ready_.HasBeenNotified(); }
13

14
 private:
15
  absl::Notification ready_;
16
};

1
// shutdown 요청 패턴
2
class Worker {
3
 public:
4
  void Shutdown() { shutdown_.Notify(); }
5

6
  void Run() {
7
    while (!shutdown_.HasBeenNotified()) {
8
      auto task = TryGetTask();
9
      if (task) Process(*task);
10
      else shutdown_.WaitForNotificationWithTimeout(absl::Milliseconds(100));
11
    }
12
  }
13

14
 private:
15
  absl::Notification shutdown_;
16
};

1
// absl/synchronization/notification.h (요약)
2
class Notification {
3
  mutable absl::Mutex mutex_;
4
  std::atomic<bool> notified_yet_;
5

6
 public:
7
  bool HasBeenNotified() const {
8
    return notified_yet_.load(std::memory_order_acquire);
9
  }
10

11
  void WaitForNotification() const {
12
    if (!HasBeenNotified()) {
13
      absl::MutexLock l(&mutex_);
14
      mutex_.Await(absl::Condition(&HasBeenNotifiedInternal, this));
15
    }
16
  }
17

18
  void Notify() {
19
    absl::MutexLock l(&mutex_);
20
    ABSL_CHECK(!notified_yet_.exchange(true, std::memory_order_release));
21
  }
22
};

1
// 회피 — atomic + busy wait
2
std::atomic<bool> ready{false};
3

4
void Wait() {
5
  while (!ready.load(std::memory_order_acquire)) {
6
    std::this_thread::yield();   // CPU 낭비
7
  }
8
}

1
// 회피 — cv 패턴 (보일러플레이트 많음)
2
std::mutex mu;
3
std::condition_variable cv;
4
bool ready = false;
5

6
void Wait() {
7
  std::unique_lock l(mu);
8
  cv.wait(l, [&] { return ready; });
9
}
10

11
void Signal() {
12
  {
13
    std::lock_guard l(mu);
14
    ready = true;
15
  }
16
  cv.notify_all();
17
}

1
// Good — Notification
2
absl::Notification n;
3

4
void Wait() { n.WaitForNotification(); }
5
void Signal() { n.Notify(); }

1
// 회피
2
std::atomic<bool> done{false};
3
while (!done.load()) std::this_thread::sleep_for(1ms);
4

5
// Good
6
absl::Notification done;
7
done.WaitForNotification();

1
// 회피
2
std::mutex mu; std::condition_variable cv; bool ready = false;
3

4
// Good
5
absl::Notification ready;

1
class JobRunner {
2
  absl::Notification cancelled_;
3
 public:
4
  void Cancel() { cancelled_.Notify(); }
5
  bool IsCancelled() const { return cancelled_.HasBeenNotified(); }
6
};

1
if (!server_ready_.WaitForNotificationWithTimeout(absl::Seconds(30))) {
2
  LOG(ERROR) << "server didn't start in 30s";
3
  return absl::DeadlineExceededError("startup timeout");
4
}

1
n.Notify();
2
n.Notify();   // ABORT — Notification 모델 위반

1
// 회피
2
absl::Notification n;
3
n.Notify(); n.WaitForNotification();
4
// 두 번째 라운드 — 새 n이 필요