c++ - 如果我在通知的条件变量上调用等待会发生什么

Question

假设我有两个线程和一个共享的 C++ 11 条件变量。如果线程 1 调用通知并在线程 2 调用等待之后会发生什么？线程 2 会永远阻塞还是会因为线程 1 调用通知而继续工作？

编辑:

enum bcLockOperation
{
    bcLockOperation_Light = -1,
    bcLockOperation_Medium = 50,
    bcLockOperation_Heavy = 1
}

class BC_COREDLL_EXP bcCustomMutex
{
private:
    bcCustomMutex(const bcCustomMutex&);
    bcCustomMutex& operator=(const bcCustomMutex&);

protected:
    bcAtomic<int> mFlag;
    bcMutex mMutex;
    bcConditionVariable mCond;

public:
    bcCustomMutex() { bcAtomicOperation::bcAtomicInit(mFlag, 0); };
    ~bcCustomMutex() {};

    void lock(bcLockOperation pLockOperation = bcLockOperation_Medium) 
    {
        bcINT32 lNewLoopCount = static_cast<bcINT32>(pLockOperation);
        bcINT32 lLoopCounter = 0;
        bcINT32 lExpected = 0;
        bcINT32 lLoopCount = bcAtomicOperation::bcAtomicLoad(mFlag, bcMemoryOrder_Relaxed); 

        while (true)
        {
            while(bcAtomicOperation::bcAtomicLoad(mFlag, bcMemoryOrder_Relaxed) != 0 && lLoopCounter != lLoopCount)
                ++lLoopCounter;

            bcAtomicOperation::bcAtomicCompareExchangeStrong(
                    mFlag, 
                    &lExpected,
                    lNewLoopCount,
                    bcMemoryOrder_Acquire,
                    bcMemoryOrder_Relaxed);
            if(lExpected == 0)
            {
                return;
            }
            else if(lLoopCounter == lLoopCount)
            {
                bcLockGuard<bcMutex> lGuard(mMutex);
                mCond.wait(mMutex);                           
            }
            else
            {
                continue;
            }
        }

        void UnLock() 
        { 
            bcAtomicOperation::bcAtomicStore(mFlag, 0, bcMemoryOrder_Relaxed);
            bcUniqueLock<bcMutex> lGuard(mMutex);
            mCond.notifyOne();
        }

        bcBOOL TryLock() 
        {
        };
    };

我想编写一个自定义互斥锁，这样每个线程都可以提供一个参数来表示当前线程想要执行的操作的复杂性。如果操作的复杂度低，其他线程将像自旋锁一样进入循环，但如果操作的复杂度中等，每个线程将迭代 50 次，然后根据条件变量休眠，如果操作非常复杂，其他线程将直接去 sleep 。

现在假设线程 1 锁定了这个互斥体，线程 2 等待，因为它的 loopCounter 到达它的末尾，就在锁定条件变量的互斥体之前，线程 1 调用条件变量上的通知。现在 thread2 将休眠，直到另一个线程锁定自定义互斥锁，然后对其调用解锁。

我是多线程的新手，我想学习。我知道我的类可能包含错误或者可能完全错误，但是有什么方法可以纠正这个问题或者有什么好的算法来编写这样的互斥量。

Answer 1

Thread2 会阻塞，直到有人调用 notify。调用以通知在调用时正在等待的释放线程。如果没有线程在等待，它们什么也不做。它们不会被保存。