国产精品久久亚洲,看片天堂,亚洲免费一区二区

開篇

多線程是開發中必不可少的，往往我們需要多個任務并行，就需要多線程開發；就好比圖像檢測和圖像結果的處理，這就是一個可閉環的任務，用多線程是可以加速這個任務的；

線程的狀態

就緒態：線程能夠運行，正在等待處理機資源；

運行態：正在運行，可能有多個線程處于運行態；

阻塞態：線程由于等待某些條件而無法運行，例如IO、鎖、互斥量等；

終止態：線程從起始函數返回或被取消；

C++學習之線程詳解

多線程的構建

有三種方式可以構建多線程，前提是都需要引入pthread.h這個頭文件；

1、函數；

2、仿函數；

3、Lambda表達式；

三者的本質都是在調用函數；

				?

									// 函數方式

									void fun(string s){

									    cout<< &s<<endl;

									    cout<< "first thread programm"<<s<<endl;

									}

									int main(){

									    string s = "Hell world";

									    thread th = thread(fun, s);

									    th.join();

									}

上面代碼為最簡單線程的一個構造；

join函數是一個等待線程完成函數，主線程需要等待子線程運行結束才可以結束；還有一個detach的函數，會讓線程在后臺運行，需要等到程序退出才結束；

計算時間

計算時間在這里介紹兩種方式：

一、程序運行時間

				?

									long n =0;

									clock_t start,finish;

									start=clock();

									while(n<1000000000)

									    n++;

									finish=clock();

									printf("spend time %f s ", (double)(finish-start)/CLOCKS_PER_SEC);

									printf("spend time %f ms ", (double)(finish-start)/1000);

這種方式和系統時間無關，一般用來調試時打印時間；

二、chrono

				?

									#include <chrono>

									//方式三 chrono

									std::chrono::system_clock::time_point Cstart = std::chrono::system_clock::now();    //系統時間

									//    std::chrono::steady_clock::time_point Cstart = std::chrono::steady_clock::now();    //穩定時間

									long n =0 ;

									while(n<1000000000)n++;

									std::chrono::system_clock::time_point Cend = std::chrono::system_clock::now();    //系統時間

									std::chrono::duration<float> spend_time = Cend-Cstart;

									cout<<spend_time.count()<<endl;

這個方式用系統時間進行計算，在實際程序中用這個方式；

共享資源和互斥鎖

關于互斥鎖的概念，引用這篇博主的講解：文章

引入互斥鎖原因：當有兩個線程共享一塊資源時，容易造成沖突，也就是上個線程還沒結束就進行下個線程，舉個例子就是讀寫操作，添加互斥鎖可以很好的解決這個沖突問題；

互斥鎖是個簡單的加鎖方法，互斥鎖只有兩種狀態：上鎖（lock）和解鎖（unlock）；

互斥鎖特點：

1、原子性：把一個互斥量鎖定為一個原子操作，這意味著如果一個線程鎖定了一個互斥量，沒有其他線程在同一時間可以成功鎖定這個互斥量；

2、唯一性：如果一個線程鎖定了一個互斥量，在它解除鎖定之前，沒有其他線程可以鎖定這個互斥量；

3、非繁忙等待：如果一個線程已經鎖定了一個互斥量，第二個線程又試圖去鎖定這個互斥量，則第二個線程將被掛起（不占用任何cpu資源），直到第一個線程解除對這個互斥量的鎖定為止，第二個線程則被喚醒并繼續執行，同時鎖定這個互斥量。

互斥鎖的使用：

				?

									mutex mtx;   //創建互斥鎖對象

									mtx.lock();

									g_pcm_elapseds.push_back(std::make_pair(pcm_data, elapsed));    // 執行語句

									mtx.unlock();

condition_variable

condition_variable條件變量可以阻塞（wait）調用的線程直到使用（notify_one或notify_all）通知恢復為止

使用案例：

				?

									std::mutex mtx;

									std::condition_variable cv;

									bool ready = false;

									void print_thread_id(int id){

									    std::unique_lock<std::mutex> lck(mtx);

									    cv.wait(lck,[]{return ready;});

									    std::cout<< "thread"<<id <<endl;

									}

									void go(){

									    std::unique_lock<std::mutex> lck(mtx);

									    ready = true;

									    cv.notify_all();    // 喚醒所有線程

									};

									int main(){

									    std::thread threads[10];

									    for(int i=0;i<10;i++){

									        threads[i] = std::thread(print_thread_id,i);

									    }

									    std::cout<< " thread read all done"<<endl;

									    go();

									    for(auto &th:threads) th.join();

									    return 0;

									}