Reihenfolge der Themen in der Ausführung

Question

Betrachten Sie diese einfache Zustimmung Beispiel:

#include <iostream>  // std::cout 
#include <thread>   // std::thread 
#include <mutex>   // std::mutex 

std::mutex mtx;   // mutex for critical section 

void print_block(int n, char c) { 
    // critical section (exclusive access to std::cout signaled by locking mtx): 
    mtx.lock(); 
    for (int i = 0; i<n; ++i) { std::cout << c; } 
    std::cout << '\n'; 
    mtx.unlock(); 
} 

int main() 
{ 
    std::thread th1(print_block, 50, '*'); 
    std::thread th2(print_block, 50, '$'); 

    th1.join(); 
    th2.join(); 

    return 0; 
} 

Ist es immer gewährleistet, dass th1 wird der erste Thread sein die for-Schleife auszuführen?

Bedeutung, wenn ich dies tun:

th1.join(); 
th2.join(); 

Dann kann ich absolut sicher sein, dass th1 zuerst ausgeführt wird und dann th2?

Answer 1

Nein, Sie sehen am wahrscheinlichsten th1 immer zuerst starten, weil Thread-Konstruktion für diese Variable zuerst erfolgt (und Thread-Konstruktion ist teuer), damit th2 beginnt nach. Das bedeutet nicht, dass es eine Bestellung gibt.

Aufruf join() hat nichts damit zu tun, was Thread zuerst ausgeführt wird, das ist bei der Konstruktion getan, wenn Sie eine aufrufbar bereitstellen.

th1 kann durch das OS aufgebaut und dann angehalten werden, die dann th2 zuerst laufen verursachen würde. Es gibt keine Reihenfolge, außer Sie implementieren eine.

dieses Beispiel betrachten, die eine viel fairer Start in beiden Threads gibt, gibt sie manchmal Faden 1 als die erste ist, um die Sperre zu erwerben, es gibt manchmal Gewinde 2.

Beispiel:

#include <iostream>   // std::cout 
#include <string>   // std::string 
#include <unordered_map> // std::unordered_map<K, V> 
#include <thread>   // std::thread 
#include <mutex>   // std::mutex 
#include <atomic>   // std::atomic<T> 

std::unordered_map<std::thread::id, std::string> thread_map; 
std::mutex mtx;   // mutex for critical section 
std::atomic<bool> go{ false }; 

void print_block(int n, char c) 
{ 
    while (!go) {} // prevent threads from executing until go is set. 
    // critical section (exclusive access to std::cout signaled by locking mtx): 
    mtx.lock(); 

    std::cout << thread_map.find(std::this_thread::get_id())->second << 
     " acquires the lock.\n"; 

    mtx.unlock(); 
} 

int main() 
{ 
    std::thread th1(print_block, 50, '*'); 
    std::thread th2(print_block, 50, '$'); 

    thread_map.emplace(std::make_pair(th1.get_id(), "Thread 1")); 
    thread_map.emplace(std::make_pair(th2.get_id(), "Thread 2")); 

    go.store(true); 

    th1.join(); 
    th2.join(); 

    return 0; 
}