如果我呼叫等待通知的条件变量会发生什么

假设我有两个线程和一个共享的c ++ 11条件变量。如果thread1调用通知并且在该thread2调用等待之后会发生什么？由于thread1的notify调用，thread2会永远阻塞还是继续工作？

编辑：

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次，然后将通过条件变量进行睡眠，如果操作非常复杂，其他线程将直接去睡觉。

现在假设线程1锁定了该互斥锁，并且线程2由于其loopCounter到达其末尾而一直等待，然后再锁定条件变量的互斥锁，线程1会在条件变量上进行通知。现在，thread2将进入睡眠状态，直到另一个线程锁定了自定义互斥锁，然后对其调用unlock。

我是多线程新手，我想学习。我知道我的班级可能包含错误或可能完全错误，但是有什么方法可以纠正此问题，也可以使用一种好的算法编写此类互斥量。