Wie viele wartende Threads werden in diesem Beispiel aktiviert:

1. Faden:

void wakeUp2Threads()
{
    std::unique_lock<std::mutex> lock(condvar_mutex);

    condvar.notify_one();
    condvar.notify_one();
}

2. Faden:

{
    std::unique_lock<std::mutex> lock(condvar_mutex);

    condvar.wait(lock); <- 2nd thread has entered here before 1st thread entered wakeUp2Threads.
}

3. Faden (das selbe wie 2nd):

{
    std::unique_lock<std::mutex> lock(condvar_mutex);

    condvar.wait(lock); <- 3rd thread has entered here before 1st thread entered wakeUp2Threads.
}

Gibt es eine Garantie dafür, dass in diesem Beispiel beide Benachrichtigungen an verschiedene Threads gesendet werden und nicht an denselben Thread mehrmals?

Dh was bedeutet notify_one ():

1) notify one thread, no matter has it been already notified (but has not been woken up yet), or not. (* see note)
or
2) notify one thread, but only this one, which has not been notified yet.

(*) Passt auf! Ich spreche hier nicht über das Szenario "Wartender Thread wurde bereits in der Vergangenheit benachrichtigt, aufgeweckt, erledigt und erneut in condvar.wait () eingegeben" - in diesem Fall können natürlich mehrere notify_one () -Routinen aufwachen der gleiche Thread immer und immer wieder.

Ich spreche von einem anderen Fall:

notify_one () hat den wartenden Thread über das Aufwecken informiert, aber BEVOR dieser wartende Thread das Zeitfenster vom Kernel-Scheduler erhalten und die Ausführung fortgesetzt hat, wurde ein weiterer notify_one () erneut aufgerufen.Ist es möglich, dass diese zweite Benachrichtigung erneut an denselben Thread gesendet wird, obwohl sie noch nicht aus der ersten Benachrichtigung aufgeweckt wurde?