Wird std :: thread ausgeführt, bevor ich join() aufruft?

Question

Nachdem ich die std::thread instanziieren beginnt es zu laufen (d. H. Call-Funktion) oder es startet nur, wenn ich join() aufrufen, das ist ein wenig unklar in den Dokumenten.

Answer 1

Es wird ausgeführt, wenn Sie es instanziieren.

Joining wird verwendet, damit der aktuelle Thread wartet, bis der andere Thread die Ausführung beendet hat.

Einige Beispiel-Code von http://en.cppreference.com/w/cpp/thread/thread/thread

void f1(int n) 
{ 
    for (int i = 0; i < 5; ++i) { 
     std::cout << "Thread 1 executing\n"; 
     ++n; 
     std::this_thread::sleep_for(std::chrono::milliseconds(10)); 
    } 
} 

void f2(int& n) 
{ 
    for (int i = 0; i < 5; ++i) { 
     std::cout << "Thread 2 executing\n"; 
     ++n; 
     std::this_thread::sleep_for(std::chrono::milliseconds(10)); 
    } 
} 

int main() 
{ 
    int n = 0; 
    std::thread t1; // t1 is not a thread 
    std::thread t2(f1, n + 1); // pass by value 
    std::thread t3(f2, std::ref(n)); // pass by reference 
    std::thread t4(std::move(t3)); // t4 is now running f2(). t3 is no longer a thread 
    t2.join(); 
    t4.join(); 
    std::cout << "Final value of n is " << n << '\n'; 
} 

    Possible output: 
Thread 1 executing 
Thread 2 executing 
Thread 1 executing 
Thread 2 executing 
Thread 1 executing 
Thread 2 executing 
Thread 1 executing 
Thread 2 executing 
Thread 2 executing 
Thread 1 executing 
Final value of n is 5 

Answer 2

Einmal std::tread erstellt es in einem Fahrzustand ist, wo es Anweisungen ausführen kann.

Es gibt keine Garantie, dass es in einem bestimmten Zeitintervall überhaupt etwas tun wird, aber die Wahrscheinlichkeit, dass es etwas tut, nähert sich immer mehr 100%, da dieses Intervall länger und länger wird.

In der Regel garantiert Design für Lebendigkeit praktisch, dass, wenn Sie in Intervallen von Zehntel Sekunden aufstehen, alle Ihre nicht wartenden Threads eine gewisse Aktivität aufweisen.