Quantos segmentos de espera serão ativados neste exemplo:

1º segmento:

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

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

2º segmento:

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

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

3º segmento (o mesmo que o segundo):

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

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

Existe alguma garantia de que neste exemplo ambas as notificações serão entregues para diferentes threads, e não o mesmo thread várias vezes?

Ou seja, o que significa 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.

(*) Preste atenção! Eu não estou falando aqui sobre o cenário "thread de espera já tinha sido notificado em algum lugar no passado, woken up, feito algumas coisas e entrou condvar.wait () novamente" - claro, neste caso, várias rotinas notify_one () podem acordar o mesmo fio repetidamente.

Estou falando de outro caso:

notify_one () notificou o thread em espera sobre o wake-up, mas ANTES que este thread em espera tenha recebido o slot de tempo do agendador do kernel e a execução continuada - outro notify_one () foi chamado novamente.É possível que esta segunda notificação seja enviada para o mesmo tópico novamente, enquanto ainda não foi despertada da primeira notificação?