【Chromium】Base库的ConditionVariable

while (!work_to_be_done()) Wait(...);

if (!work_to_be_done()) Wait(...);  // 不要这样

class BASE_EXPORT ConditionVariable {
public:
    // 为一个用户锁构造一个条件变量。
    explicit ConditionVariable(Lock* user_lock);

    ~ConditionVariable();

    // Wait() 在开始睡眠时原子性地释放调用者的临界区，并在收到信号时重新获取它。等待函数容易受到虚假唤醒的影响（有关更多详细信息，请参见使用注意事项1）。
    void Wait();
    void TimedWait(const TimeDelta& max_time);

    // Broadcast() 唤醒所有等待的线程（有关更多详细信息，请参见使用注意事项2）。
    void Broadcast();
    // Signal() 唤醒一个等待的线程。
    void Signal();

    // 声明此 ConditionVariable 只会被一个空闲线程在堆栈底部使用，并在等待工作时（特别是在恢复进行中的工作之前）不会同步等待此 ConditionVariable。这对于避免告诉基础内部此线程被“阻塞”，而实际上它只是空闲并准备好工作是有用的。因此，这仅预期由线程和线程池实现使用。
    void declare_only_used_while_idle() { waiting_is_blocking_ = false; }

private:
#if defined(OS_WIN)
    CHROME_CONDITION_VARIABLE cv_;
    CHROME_SRWLOCK* const srwlock_;
#elif defined(OS_POSIX) || defined(OS_FUCHSIA)
    pthread_cond_t condition_;
    pthread_mutex_t* user_mutex_;
#endif

#if DCHECK_IS_ON()
    base::Lock* const user_lock_;  // 在等待时需要调整阴影锁状态。
#endif

    // 一个线程在调用此 ConditionVariable 上的 Wait() 时，是否应被视为被阻塞而不是空闲（如果是线程池的一部分，则可能被替换）。
    bool waiting_is_blocking_ = true;

    DISALLOW_COPY_AND_ASSIGN(ConditionVariable);
}

ConditionVariable::ConditionVariable(Lock* user_lock)
    : srwlock_(user_lock->lock_.native_handle())
#if DCHECK_IS_ON()
    , user_lock_(user_lock)
#endif
{
    DCHECK(user_lock);
    InitializeConditionVariable(reinterpret_cast<PCONDITION_VARIABLE>(&cv_));
}

ConditionVariable::~ConditionVariable() = default;

void ConditionVariable::Wait() {
    TimedWait(TimeDelta::FromMilliseconds(INFINITE));
}

void ConditionVariable::TimedWait(const TimeDelta& max_time) {
    Optional<internal::ScopedBlockingCallWithBaseSyncPrimitives>
        scoped_blocking_call;
    if (waiting_is_blocking_)
        scoped_blocking_call.emplace(BlockingType::MAY_BLOCK);

    DWORD timeout = static_cast<DWORD>(max_time.InMilliseconds());

#if DCHECK_IS_ON()
    user_lock_->CheckHeldAndUnmark();
#endif

    if (!SleepConditionVariableSRW(reinterpret_cast<PCONDITION_VARIABLE>(&cv_),
        reinterpret_cast<PSRWLOCK>(srwlock_), timeout,
        0)) {
        // 在失败的情况下，我们只期望条件变量超时。任何其他错误值都意味着我们意外地被唤醒。 
        // 注意，WAIT_TIMEOUT != ERROR_TIMEOUT。WAIT_TIMEOUT 用于 WaitFor* 函数族作为直接返回值。ERROR_TIMEOUT 用于 GetLastError()。
        DCHECK_EQ(static_cast<DWORD>(ERROR_TIMEOUT), GetLastError());
    }

#if DCHECK_IS_ON()
    // Debug模式下，还会检查当前超时被唤醒时线程是否符合预期等待前的线程
    user_lock_->CheckUnheldAndMark();
#endif
}

void ConditionVariable::Broadcast() {
    WakeAllConditionVariable(reinterpret_cast<PCONDITION_VARIABLE>(&cv_));
}

void ConditionVariable::Signal() {
    WakeConditionVariable(reinterpret_cast<PCONDITION_VARIABLE>(&cv_));
}

Lock lock;
ConditionVariable cv(&lock);
lock.Acquire();

TimeTicks start = TimeTicks::Now();
const TimeDelta WAIT_TIME = TimeDelta::FromMilliseconds(300);
const TimeDelta FUDGE_TIME = TimeDelta::FromMilliseconds(50);

cv.TimedWait(WAIT_TIME + FUDGE_TIME);
TimeDelta duration = TimeTicks::Now() - start;

// GTest框架
EXPECT_TRUE(duration >= WAIT_TIME);

lock.Release();