如何讓C++ 11線程運行多個不同的函數？

Question

我正在學習C++ 11中的新多線程技術。幾乎我在網上閱讀的所有教程都教導如何啓動執行功能的新線程（或多個線程），以後如何加入（或拆離）線程（或線程），以及如何避免使用mutex等的競速條件

但是我沒有看到其中的任何一個顯示如何讓一個線程在程序的不同部分執行幾個函數。問題是，使用C++ 11線程，是否有可能實現以下目標？如果是這樣，怎麼樣？ （舉個例子會很棒）。

void func1(std::vector<int> & data1){ ... } 

void func2(std::vector<int> & data2){ ... } 

// main function version I 
int main(){ 
    std::vector<int> data1; 
    // prepare data1 for func1; 
    std::thread t1(func1, std::ref(data1)); 

    std::vector<int> data2; 
    // prepare data2 for func2; 
    if (func1 in t1 is done){ 
     t1(func2, std::ref(data2)); 
    } 

    t1.join(); 
    return 0;  
} 

而且進一步，如果我想要把上述main函數體進入一個循環，如下什麼。可能嗎？如果是這樣，怎麼樣？從cplusplus.com

//main function version II 
int main(){ 
    std::vector<int> bigdata1; 
    std::vector<int> bigdata2; 

    std::thread t1; // Can I do this without telling t1 the function 
        // to be executed? 

    for(int i=0; i<10; ++i){ 
     // main thread prepare small chunk smalldata1 from bigdata1 for func1; 

     if(t1 is ready to execute a function){t1(func1, std::ref(smalldata1));} 

     // main thread do other stuff, and prepare small chunk smalldata2 from bigdata2 for func2; 

     if (func1 in t1 is done){ 
      t1(func2, std::ref(smalldata2)); 
     } 
    } 

    t1.join(); 
    return 0;  
} 

Answer 1

參考：

默認的構造構造一個線程對象，並不代表任何執行線程。

因此std::thread t根本沒有定義一個可執行的線程。線程函數必須在創建線程時提供，並且之後不能設置。

對於您的主要功能版本I，您將不得不創建兩個線程。東西如下所示：

int main(){ 
    std::vector<int> data1; 
    // prepare data1 for func1; 
    std::thread t1(func1, std::ref(data1)); 

    std::vector<int> data2; 
    // prepare data2 for func2; 
    t1.join(); // this is how you wait till func1 is done 

    // you will have to create a new thread here for func2 
    std::thread t2(func2, std::ref(data2)); 
    t2.join(); // wait for thread2 (func2) to end 

    return 0;  
} 

同樣，你可以把它們放在一個循環，這是正常的，這將給你主要功能版II。

Answer 2

C++ 11線程是旨在允許您編寫真實庫的原語。他們不容易使用。你應該包裹它們。

喜歡的東西：

struct tasks { 
    std::mutex m; 
    std::condition_variable v; 
    std::vector<std::packaged_task<void>> work; 
    std::vector<std::future<void>> finished; 
    void operator()(){ 
    while(true){ 
     std::packaged_task<void> f; 
     { 
     std::unique_lock<std::mutex> l(m); 
     if (work.empty()){ 
      v.wait(l,[&]{return !work.empty();}); 
     } 
     f = std::move(work.front()); 
     work.pop_front(); 
     } 
     if (!f.valid()) return; 
     f(); 
    } 
    } 
    std::future<void> do(std::function<void()> f){ 
    std::packaged_task<void> p(f); 
    auto r=p.get_future(); 
    { 
     std::unique_lock<std::mutex> l(m); 
     work.push_back(std::move(p)); 
     v.notify_one(); 
    } 
    return r; 
    } 
    void start(){ 
    finished.push_back(std::async(std::launch_policy::async, 
     std::ref(*this))); 
    } 
    ~tasks(){ 
    std::unique_lock<std::mutex> l(m); 
    for(auto&&unused:finished){ 
     work.push_back({}); 
    } 
    v.notify_all(); 
    } 
}; 

使用的樣子：

int main(){ 
    tasks t; 
    t.start(); 
    t.do([]({std::cout<<"hello ";}); 
    t.do([]({std::cout<<"world\n";}); 
} 

，如果你想知道當任務完成後，檢查未來do回報。

寫在手機上，沒有編譯，可能是完整的錯別字和錯誤，但一個地方開始。

不支持提前中止。易於編寫abaondon它清空work。

支持多個消費者（workwe線程）我懷疑。在兼容系統上，dtor將等待所有線程完成排隊的作業。不在MSVC2013壽。