About mit6.828_ HW9_ Some problems of barriers xv6 homework9

Recently learning MIT6.828, Did HomeWork9:barriers.
The main idea is to implement a thread barrier , Multiple threads will call barrier() function , Then ask all threads to enter this barrier Function before leaving barrier.
My realization is like this ：

/*nthread Is the total number of threads ,bstate.nthread Yes, the initial value is 0 A counter for */
static void barrier()
{
    
#define wait() pthread_cond_wait(&bstate.barrier_cond, &bstate.barrier_mutex)
#define notify() pthread_cond_broadcast(&bstate.barrier_cond)

    static int resume = 0; //  Express wait1,wait2 The state of 
    
    pthread_mutex_lock(&bstate.barrier_mutex);
    ++bstate.nthread; // safe
    notify();

    while (bstate.nthread < nthread && !resume)
        wait(); // wait1

    resume = 1; //  Avoid having threads execute --bstate.nthread Destroyed the triggered wait1 Conditions ,

    --bstate.nthread;
    if (bstate.nthread == 0)
        bstate.round++;
    notify();

    while (bstate.nthread > 0 && resume)
        wait(); // wait2

    resume = 0; //  Avoid having threads execute ++bstate.nthread Destroyed the triggered wait2 Conditions ,

    pthread_mutex_unlock(&bstate.barrier_mutex);

#undef wait
#undef notify
}

But when I try to search for standard answers on the Internet , The realization of uniformity is like this ：

static void barrier()
{
    
    pthread_mutex_lock(&bstate.barrier_mutex);
    bstate.nthread++;
    if (bstate.nthread == nthread)
    {
    
        //  The last process enters   perform  round++,  Wake up other processes .
        bstate.round++;
        bstate.nthread = 0;
        //  Wake up other processes 
        pthread_cond_broadcast(&bstate.barrier_cond); // BBB
    }
    else
    {
       //  Is there no false wake-up problem ？
        pthread_cond_wait(&bstate.barrier_cond, &bstate.barrier_mutex); // AAA
    }

    pthread_mutex_unlock(&bstate.barrier_mutex);
}

Undertested , Both implementations work properly .
however , I think there is a risk of false awakening in the implementation of online （ Humble opinion of Xiaobai , If there is any misunderstanding, please point out ）：

• Under normal circumstances , If the total is 4 Threads , After the current three threads enter , They will all be blocked in AAA In the sentence , Until the fourth thread enters and executes BBB sentence , front 3 All threads will start from wait Wake up in , Then get the lock in turn to unlock and then exit barrier().
• however , If the first three threads are blocked in AAA after , Threads 4 Not yet in barrier() function , Then there is a false wake-up at the operating system level , Cause before 3 Threads from wait Back in , Then they will exit directly barrier(), This violates the definition of barrier .

I hope to have some good advice .