C++之多線程（C++11 thread.h文件實現(xiàn)多線程）

禁忌石 2017-05-30

展開全文

C++之多線程（C++11 thread.h文件實現(xiàn)多線程）

標簽： c++11多線程 thread

2016-06-14 21:30 6344人閱讀評論(2) 收藏舉報

分類：

C++基礎（38）

轉載自：

http://www.cnblogs.com/haippy/p/3235560.html

http://www.cnblogs.com/lidabo/p/3908705.html

與 C++11 多線程相關的頭文件
C++11 新標準中引入了四個頭文件來支持多線程編程，他們分別是<atomic> ,<thread>,<mutex>,<condition_variable>和<future>。
<atomic>：該頭文主要聲明了兩個類, std::atomic 和 std::atomic_flag，另外還聲明了一套 C 風格的原子類型和與 C 兼容的原子操作的函數(shù)。
<thread>：該頭文件主要聲明了 std::thread 類，另外 std::this_thread 命名空間也在該頭文件中。
<mutex>：該頭文件主要聲明了與互斥量(mutex)相關的類，包括 std::mutex 系列類，std::lock_guard, std::unique_lock, 以及其他的類型和函數(shù)。
<condition_variable>：該頭文件主要聲明了與條件變量相關的類，包括 std::condition_variable 和 std::condition_variable_any。
<future>：該頭文件主要聲明了 std::promise, std::package_task 兩個 Provider 類，以及 std::future 和 std::shared_future 兩個 Future 類，另外還有一些與之相關的類型和函數(shù)，std::async() 函數(shù)就聲明在此頭文件中。
demo1：thread "Hello world"

[cpp] view plaincopy
#include <stdio.h>  
#include <stdlib.h>  
#include <iostream> // std::cout  
#include <thread>   // std::thread  
void thread_task() {  
    std::cout << "hello thread" << std::endl;  
}  
int main(int argc, const char *argv[])  
{  
    std::thread t(thread_task);  
    t.join();//和主線程協(xié)同  
    return EXIT_SUCCESS;  
}  

demo2：一次啟動多個線程
我們通常希望一次啟動多個線程，來并行工作。為此，我們可以創(chuàng)建線程組，而不是在先前的舉例中那樣創(chuàng)建一條線程。下面的例子中，主函數(shù)創(chuàng)建十條為一組的線程，并且等待這些線程完成他們的任務

[cpp] view plaincopy
#include <stdio.h>  
#include <stdlib.h>  
#include <iostream> // std::cout  
#include <thread>   // std::thread  
int main() {  
    std::thread t[num_threads];  
    //Launch a group of threads 啟動一組線程  
    for (int i = 0; i < num_threads; ++i) {  
        t[i] = std::thread(call_from_thread);  
    }  
    std::cout << "Launched from the mainn";  
    //Join the threads with the main thread  
    for (int i = 0; i < num_threads; ++i) {  
        t[i].join();  
    }  
    return 0;  
}  

記住，主函數(shù)也是一條線程，通常叫做主線程，所以上面的代碼實際上有11條線程在運行。在啟動這些線程組之后，線程組和主函數(shù)進行協(xié)同（join）之前，允許我們在主線程中做些其他的事情。
demo3：在線程中使用帶有形參的函數(shù)

[cpp] view plaincopy
#include <stdio.h>  
#include <stdlib.h>  
#include <iostream> // std::cout  
#include <thread>   // std::thread  
static const int num_threads = 10;  
//This function will be called from a thread  
void call_from_thread(int tid) {  
    std::cout << "Launched by thread " << tid << std::endl;  
}  
int main() {  
    std::thread t[num_threads];  
    //Launch a group of threads  
    for (int i = 0; i < num_threads; ++i) {  
        t[i] = std::thread(call_from_thread, i);  
    }  
    std::cout << "Launched from the mainn";  
    //Join the threads with the main thread  
    for (int i = 0; i < num_threads; ++i) {  
        t[i].join();  
    }  
    return 0;  
}  

運行結果：

[plain] view plaincopy
Sol$ ./a.out  
  
Launched by thread 0  
  
Launched by thread 1  
  
Launched by thread 2  
  
Launched from the main  
  
Launched by thread 3  
  
Launched by thread 5  
  
Launched by thread 6  
  
Launched by thread 7  
  
Launched by thread Launched by thread 4  
  
8L  
  
aunched by thread 9  
  
Sol$

能看到上面的結果中，程序一旦創(chuàng)建一條線程，其運行存在先后秩序不確定的現(xiàn)象。程序員的任務就是要確保這組線程在訪問公共數(shù)據(jù)時不要出現(xiàn)阻塞。最后幾行，所顯示的錯亂輸出，表明8號線程啟動的時候，4號線程還沒有完成在stdout上的寫操作。事實上假定在你自己的機器上運行上面的代碼，將會獲得全然不同的結果，甚至是會輸出些混亂的字符。原因在于，程序內的11條線程都在競爭性地使用stdout這個公共資源（案：Race Conditions）。
要避免上面的問題，可以在代碼中使用攔截器（barriers），如std:mutex，以同步（synchronize）的方式來使得一群線程訪問公共資源，或者，如果可行的話，為線程們預留下私用的數(shù)據(jù)結構，避免使用公共資源。我們在以后的教學中，還會講到線程同步問題，包括使用原子操作類型（atomic types）和互斥體（mutex）。