Powiadamianie kilku wątków w tym samym momencie o gotowości do działania

Cześć.

Mam taki prosty przykład kodu, który ma 3 funkcje i chciałbym aby wszystkie rozpoczynały wykonywanie kodu w tym samym momencie po otrzymaniu powiadomienia.
W momencie wywołania notify(), mutexy są zwalniane w losowej kolejności. I teraz tak, jeżeli najpierw zostanie zwolniony mutex w foo_1() to couty (2) i (3) uruchomią się dopiero po wykonaniu fragmentu (1), czyli 5-sekundowym uśpieniu.
Dlaczego, skoro każda z tych funkcji jest uruchomiona w osobnym wątku?
Czy notify do kolejnego mutexa idzie dopiero jak poprzedni zostanie ponownie zablokowany?

#include <iostream>
#include <thread>
#include <mutex>
#include <condition_variable>


using namespace std;

std::mutex mtx;
std::condition_variable cond;

void notify(){
    this_thread::sleep_for(chrono::seconds(2));
    cond.notify_all();
}

void foo_1(){
    cout << "foo_1 started" << endl;
    while(true) {
        std::unique_lock<std::mutex> lock {mtx};
        cond.wait(lock);

        this_thread::sleep_for(chrono::seconds(5)); // (1)
        
        cout << "foo_1" << endl;
    }
}

void foo_2(){
    cout << "foo_2 started" << endl;
    while(true) {
        std::unique_lock<std::mutex> lock {mtx};
        cond.wait(lock);

        cout << "foo_2" << endl;        // (2)
    }
}

void foo_3(){
    cout << "foo_3 started" << endl;
    while(true) {
        std::unique_lock<std::mutex> lock {mtx};
        cond.wait(lock);

        cout << "foo_3" << endl;        //  (3)
    }
}


int main(int argc, char** argv) {
    
    thread t_foo_1 (foo_1);
    thread t_foo_2 (foo_2);
    thread t_foo_3 (foo_3);
    thread t_notify (notify);
    
    
    t_foo_1.join();
    t_foo_2.join();
    t_foo_3.join();
    t_notify.join();
    
    return 0;
}

używasz tego samego mutexu, przez co tylko jeden wait jest zwalniany naraz. dopiero gdy mutex związany z tym waitem zostanie odblokowany, inne waity również będą mogły zostać zwolnione.