溫馨提示×
您好，登錄后才能下訂單哦！
點擊 登錄注冊 即表示同意《億速云用戶服務條款》
您好，登錄后才能下訂單哦！
這篇“C++11線程、互斥量及條件變量怎么創建”文章的知識點大部分人都不太理解，所以小編給大家總結了以下內容，內容詳細，步驟清晰，具有一定的借鑒價值，希望大家閱讀完這篇文章能有所收獲，下面我們一起來看看這篇“C++11線程、互斥量及條件變量怎么創建”文章吧。
C++11之前，C++語言沒有對并發編程提供語言級別的支持，這使得我們在編程寫可移植的并發程序時，存在諸多不便。現在C++11增加了線程以及線程相關的類，很方便地支持了并發編程，使得編寫多線程程序的可移植性得到了很大的提高
//創建線程需要引入頭文件thread
#include<thread>
#include<iostream>
void ThreadMain()
{
cout << "begin thread main" << endl;
}
int main()
{
//創建新線程t并啟動
thread t(ThreadMain);
//主線程(main線程)等待t執行完畢
if (t.joinable()) //必不可少
{
//等待子線程退出
t.join(); //必不可少
}
return 0;
}我們都知道，對于一個單線程來說，也就main線程或者叫做主線程，所有的工作都是由main線程去完成的。而在多線程環境下，子線程可以分擔main線程的工作壓力，在多個CPU下，實現真正的并行操作。
在上述代碼中，可以看到main線程創建并啟動了一個新線程t，由新線程t去執行ThreadMain()函數，jion函數將會把main線程阻塞住，知道新線程t執行結束，如果新線程t有返回值，返回值將會被忽略
我們可以通過函數this_thread::get_id()來判斷是t線程還是main線程執行任務
void ThreadMain()
{
cout << "線程" << this_thread::get_id()<< ":begin thread main" << endl;
}
int main()
{
//創建新線程t并啟動
thread t(ThreadMain);
//主線程(main線程)等待t執行完畢
if (t.joinable()) //必不可少
{
//等待子線程退出
cout << "線程" << this_thread::get_id() << ":正在等待" << endl;
t.join(); //必不可少
}
return 0;
}執行結果：
void func()
{
cout << "do func" << endl;
}
int main()
{
thread t(func);
return 0;
}上訴代碼運行可能會拋出異常，因為線程對象t可能先于線程函數func結束，應該保證線程對象的生命周期在線程函數func執行完時仍然存在
為了防止線程對象的生命周期早于線程函數fun結束，可以使用線程等待join
void func()
{
while (true)
{
cout << "do work" << endl;
this_thread::sleep_for(std::chrono::seconds(1));//當前線程睡眠1秒
}
}
int main()
{
thread t(func);
if (t.joinable())
{
t.join();//main線程阻塞
}
return 0;
}雖然使用join能有效防止程序的崩潰，但是在某些情況下，我們并不希望main線程通過join被阻塞在原地，此時可以采用detach進行線程分離。但是需要注意：detach之后main線程就無法再和子線程發生聯系了，比如detach之后就不能再通過join來等待子線程，子線程任何執行完我們也無法控制了
void func()
{
int count = 0;
while (count < 3)
{
cout << "do work" << endl;
count++;
this_thread::sleep_for(std::chrono::seconds(1));//當前線程睡眠1秒
}
}
int main()
{
thread t(func);
t.detach();
this_thread::sleep_for(std::chrono::seconds(1));//當前線程睡眠1秒
cout << "線程t分離成功" << endl;
return 0;
}執行結果：
線程的創建和執行，無非是給線程指定一個入口函數嘛，例如main線程的入口函數就main()函數，前面編寫的子線程的入口函數是一個全局函數。除了這些之外線程的入口函數還可以是函數指針、仿函數、類的成員函數、lambda表達式等，它們都有一個共同的特點：都是可調用對象。線程的入口函數指定，可以為任意一個可調用對象。
普通函數作為線程的入口函數
void func()
{
cout << "hello world" << endl;
}
int main()
{
thread t(func);
if (t.joinable())
{
t.join();
}
return 0;
}類的成員函數作為線程的入口函數
class ThreadMain
{
public:
ThreadMain() {}
virtual ~ThreadMain(){}
void SayHello(std::string name)
{
cout << "hello " << name << endl;
}
};
int main()
{
ThreadMain obj;
thread t(&ThreadMain::SayHello, obj, "fl");
thread t1(&ThreadMain::SayHello, &obj, "fl");
t.join();
t1.join();
return 0;
}t和t1在傳遞參數時存在不同：
t是用對象obj調用線程函數的語句，即線程函數將在obj對象的上下文中運行。這里obj是通過值傳遞給線程構造函數的，因此在線程中使用的是對象obj的一個副本。這種方式適用于類定義在局部作用域中時，需要將其傳遞給線程的情況。
t1是使用對象的指針&obj調用線程函數的語句，即線程函數將在對象obj的指針所指向的上下文中運行。這里使用的是對象obj的指針，因此在線程中使用的是原始的obj對象。這種方式適用于類定義在全局或靜態作用域中時，需要將其傳遞給線程的情況。
如果需要在類的成員函數中，創建線程，以類中的另一個成員函數作為入口函數，再執行
class ThreadMain
{
public:
ThreadMain() {}
virtual ~ThreadMain(){}
void SayHello(std::string name)
{
cout << "hello " << name << endl;
}
void asycSayHello(std::string name)
{
thread t(&ThreadMain::SayHello, this, name);
if (t.joinable())
{
t.join();
}
}
};
int main()
{
ThreadMain obj;
obj.asycSayHello("fl");
return 0;
}在asycSayHello的成員函數中，如果沒有傳遞this指針，會導致編譯不通過
原因就是參數列表不匹配，因此需要我們顯示的傳遞this指針，表示以本對象的成員函數作為參數的入口函數
lambda表達式作為線程的入口函數
int main()
{
thread t([](int i){
cout << "test lambda i = " << i << endl;
}, 123);
if (t.joinable())
{
t.join();
}
return 0;
}執行結果：
在類的成員函數中，以lambda表達式作為線程的入口函數
class TestLmadba
{
public:
void Start()
{
thread t([this](){
cout << "name is " << this->name << endl;
});
if (t.joinable())
{
t.join();
}
}
private:
std::string name = "fl";
};
int main()
{
TestLmadba test;
test.Start();
return 0;
}在類的成員函數中，以lambda表達式作為線程的入口函數，如果需要訪問兌現的成員變量，也需要傳遞this指針
仿函數作為線程的入口函數
class Mybusiness
{
public:
Mybusiness(){}
virtual ~Mybusiness(){}
void operator()(void)
{
cout << "Mybusiness thread id is " << this_thread::get_id() << endl;
}
void operator()(string name)
{
cout << "name is " << name << endl;
}
};
int main()
{
Mybusiness mb;
thread t(mb);
if (t.joinable())
{
t.join();
}
thread t1(mb, "fl");
if (t1.joinable())
{
t1.join();
}
return 0;
}執行結果：
線程t以無參的仿函數作為函數入口，而線程t1以有參的仿函數作為函數入口
函數指針作為線程的入口函數
void func()
{
cout << "thread id is " << this_thread::get_id() << endl;
}
void add(int a, int b)
{
cout << a << "+" << b << "=" << a + b << endl;
}
int main()
{
//采用C++11擴展的using來定義函數指針類型
using FuncPtr = void(*)();
using FuncPtr1 = void(*)(int, int);
//使用FuncPtr來定義函數指針變量
FuncPtr ptr = &func;
thread t(ptr);
if (t.joinable())
{
t.join();
}
FuncPtr1 ptr1 = add;
thread t1(ptr1, 1, 10);
if (t1.joinable())
{
t1.join();
}
return 0;
}執行結果：
function和bind作為線程的入口函數
void func(string name)
{
cout << this_thread::get_id() << ":name is " << name << endl;
}
int main()
{
function<void(string)> f(func);
thread t(f, "fl");
if (t.joinable())
{
t.join();
}
thread t1(bind(func, "fl"));
if (t1.joinable())
{
t1.join();
}
return 0;
}執行結果：
線程不能拷貝和復制，但可以移動
//賦值操作
void func(string name)
{
cout << this_thread::get_id() << ":name is " << name << endl;
}
int main()
{
thread t1(func, "fl");
thread t2 = t1;
thread t3(t1);
return 0;
}編譯報錯：
在線程內部，已經將線程的賦值和拷貝操作delete掉了，所以無法調用到
//移動操作
void func(string name)
{
cout << this_thread::get_id() << ":name is " << name << endl;
}
int main()
{
thread t1(func, "fl");
thread t2(std::move(t1));
if (t1.joinable())
{
t1.join();
}
if (t2.joinable())
{
t2.join();
}
return 0;
}執行結果：
線程被移動之后，線程對象t1將不代表任何線程了，可以通過調試觀察到
當多個線程同時訪問同一個共享資源時，如果不加以保護或者不做任何同步操作，可能出現數據競爭或不一致的狀態，導致程序運行出現問題。
為了保證所有的線程都能夠正確地、可預測地、不產生沖突地訪問共享資源，C++11提供了互斥量。
互斥量是一種同步原語，是一種線程同步手段，用來保護多線程同時訪問的共享數據。互斥量就是我們平常說的鎖
C++11中提供了4種語義的互斥量
std::mutex：獨占的互斥量，不能遞歸
std::timed_mutex：帶超時的獨占互斥量，不能遞歸使用
std::recursive_mutex：遞歸互斥量，不能帶超時功能
std::recursive_timed_mutex：帶超時的遞歸互斥量
這些互斥量的接口基本類似，一般用法是通過lock()方法來阻塞線程，知道獲得互斥量的所有權為止。在線程獲得互斥量并完成任務之后，就必須使用unlock()來解除對互斥量的占用，lock()和unlock()必須成對出現。try_lock()嘗試鎖定互斥量，如果成功則返回true，失敗則返回false，它是非阻塞的。
int num = 0;
std::mutex mtx;
void func()
{
for (int i = 0; i < 100; ++i)
{
mtx.lock();
num++;
mtx.unlock();
}
}
int main()
{
thread t1(func);
thread t2(func);
if (t1.joinable())
{
t1.join();
}
if (t2.joinable())
{
t2.join();
}
cout << num << endl;
return 0;
}執行結果：
使用lock_guard可以簡化lock/unlock的寫法，同時也更安全，因為lock_guard在構造時會自動鎖定互斥量，而在退出作用域后進行析構時自動解鎖，從而保證了互斥量的正確操作，避免忘記unlock操作，因此，盡量用lock_guard。lock_guard用到了RALL技術，這種技術在類的構造函數中分配資源，在析構函數中釋放資源，保證資源在出了作用域之后就釋放。上面的例子使用lock_guard后會更簡介，代碼如下：
void func()
{
for (int i = 0; i < 100; ++i)
{
lock_guard<mutex> lock(mtx);
num++;
}
}一般來說，當某個線程執行操作完畢后，釋放鎖，然后需要等待幾十毫秒，讓其他線程也去獲取鎖資源，也去執行操作。如果不進行等待的話，可能當前線程釋放鎖后，又立馬獲取了鎖資源，會導致其他線程出現饑餓。
遞歸鎖允許同一線程多次獲得該互斥鎖，可以用來解決同一線程需要多次獲取互斥量時死鎖的問題。在以下代碼中，一個線程多次獲取同一個互斥量時會發生死鎖：
class Complex
{
public:
std::mutex mtx;
void SayHello()
{
lock_guard<mutex> lock(mtx);
cout << "Say Hello" << endl;
SayHi();
}
void SayHi()
{
lock_guard<mutex> lock(mtx);
cout << "say Hi" << endl;
}
};
int main()
{
Complex complex;
complex.SayHello();
return 0;
}執行結果：
這個例子運行起來就發生了死鎖，因為在調用SayHello時獲取了互斥量，之后再調用SayHI又要獲取相同的互斥量，但是這個互斥量已經被當前線程獲取 ，無法釋放，這時就會產生死鎖，導致程序崩潰。
要解決這里的死鎖問題，最簡單的方法就是采用遞歸鎖：std::recursive_mutex，它允許同一個線程多次獲取互斥量
class Complex
{
public:
std::recursive_mutex mtx;//同一線程可以多次獲取同一互斥量，不會發生死鎖
void SayHello()
{
lock_guard<recursive_mutex> lock(mtx);
cout << "Say Hello" << endl;
SayHi();
}
void SayHi()
{
lock_guard<recursive_mutex> lock(mtx);
cout << "say Hi" << endl;
}
};執行結果：
需要注意的是盡量不要使用遞歸鎖比較好，主要原因如下：
1、需要用到遞歸鎖定的多線程互斥量處理往往本身就是可以簡化的，允許遞歸互斥量很容易放縱復雜邏輯的產生，而非導致一些多線程同步引起的晦澀問題
2、遞歸鎖的效率比非遞歸鎖的效率低
3、遞歸鎖雖然允許同一個線程多次獲得同一個互斥量，但可重復的最大次數并為具體說明，一旦超過一定次數，再對lock進行調用就會拋出std::system錯誤
4.3 帶超時的互斥量std::timed_mutex和std::recursive_timed_mutex
std::timed_mutex是超時的獨占鎖，srd::recursive_timed_mutex是超時的遞歸鎖，主要用在獲取鎖時增加超時鎖等待功能，因為有時不知道獲取鎖需要多久，為了不至于一直在等待獲互斥量，就設置一個等待超時時間，在超時時間后還可做其他事。
std::timed_mutex比std::mutex多了兩個超時獲取鎖的接口：try_lock_for和try_lock_until，這兩個接口是用來設置獲取互斥量的超時時間，使用時可以用一個while循環去不斷地獲取互斥量。
std::timed_mutex mtx;
void work()
{
chrono::milliseconds timeout(100);
while (true)
{
if (mtx.try_lock_for(timeout))
{
cout << this_thread::get_id() << ": do work with the mutex" << endl;
this_thread::sleep_for(chrono::milliseconds(250));
mtx.unlock();
}
else
{
cout << this_thread::get_id() << ": do work without the mutex" << endl;
this_thread::sleep_for(chrono::milliseconds(100));
}
}
}
int main()
{
thread t1(work);
thread t2(work);
if (t1.joinable())
{
t1.join();
}
if (t2.joinable())
{
t2.join();
}
return 0;
}執行結果：
在上面的例子中，通過一個while循環不斷地去獲取超時鎖，如果超時還沒有獲取到鎖時就休眠100毫秒，再繼續獲取鎖。
相比std::timed_mutex，std::recursive_timed_mutex多了遞歸鎖的功能，允許同一個線程多次獲得互斥量。std::recursive_timed_mutex和std::recursive_mutex的用法類似，可以看作在std::recursive_mutex的基礎上增加了超時功能
lock_guard和unique_lock的功能完全相同，主要差別在于unique_lock更加靈活，可以自由的釋放mutex，而lock_guard需要等到生命周期結束后才能釋放。
它們的構造函數中都有第二個參數
unique_lock：
lock_guard：
可以從源碼中看到，unique_lock的構造函數中，第二個參數的種類有三種，分別是adopt_lock，defer_lock和try_to_lock。lock_guard的構造函數中，第二個參數的種類只有一種，adopt_lock
這些參數的含義分別是：
adopt_lock：互斥量已經被lock，構造函數中無需再lock(lock_ guard與unique_lock通用)
defer_lock：互斥量稍后我會自行lock，不需要在構造函數中lock，只初始化一個沒有加鎖的mutex
try_to_lock：主要作用是在不阻塞線程的情況下嘗試獲取鎖，如果互斥量當前未被鎖定，則返回std::unique_lock對象，該對象擁有互斥量并且已經被鎖定。如果互斥量當前已經被另一個線程鎖定，則返回一個空的std::unique_lock對象
mutex mtx;
void func()
{
//mtx.lock();//需要加鎖，否則在lock的生命周期結束后，會自動解鎖，則會導致程序崩潰
unique_lock<mutex> lock(mtx, std::adopt_lock);
cout << this_thread::get_id() << " do work" << endl;
}
int main()
{
thread t(func);
if (t.joinable())
{
t.join();
}
return 0;
}執行結果：
adopt_lock就表示構造unique_lock<mutex>時，認為mutex已經加過鎖了，就不會再加鎖了，它就把加鎖的權限和時機交給了我們，由我們自己控制
mutex mtx;
void func()
{
while (true)
{
unique_lock<mutex> lock(mtx, std::defer_lock);
cout << "func thread id is " << this_thread::get_id() << endl;
this_thread::sleep_for(chrono::milliseconds(500));
}
}
int main()
{
thread t1(func);
thread t2(func);
if (t1.joinable())
{
t1.join();
}
if (t2.joinable())
{
t2.join();
}
return 0;
}執行結果：
本來我們的意愿是t1和t2每個時刻只能有一個線程打印"func thread id is…"，但是實際上卻發生了競爭的關系，原因就在于defer_lock在構造unique_lock<mutex>時，認為mutex在后面會加鎖，也就沒有加鎖，所以打印結果才發生混亂，因此需要我們手動改進一下
void func()
{
while (true)
{
unique_lock<mutex> lock(mtx, std::defer_lock);
lock.lock();
cout << "func thread id is " << this_thread::get_id() << endl;
this_thread::sleep_for(chrono::milliseconds(500));
//lock.unlock(); //可以加，也可以不加
//因為內部有一個標準為，如果我們自己手動解鎖了，由于標志位的改變，在調用lock的析構函數時，就不會進行解鎖操作
}
}執行結果：
為了保證在多線程環境中某個函數僅被調用一次，比如，需要在初始化某個對象，而這個對象只能初始化一次時，就可以用std::call_once來保證函數在多線程環境中只能被調用一次。使用std::call_once時，需要一個once_flag作為call_once的入參，用法比較簡單
call_once函數模板
在使用call_once時，第一個參數是類型為once_flag的標志位，第二個參數是一個可調用對象，第三個為可變參數，表示的可調用對象中的參數
std::once_flag flag;
void do_once()
{
std::call_once(flag, [](){
cout << "call once" << endl;
});
}
int main()
{
const int ThreadSize = 5;
vector<thread> threads;
for (int i = 0; i < ThreadSize; ++i)
{
threads.emplace_back(do_once);
}
for (auto& t : threads)
{
if (t.joinable())
{
t.join();
}
}
return 0;
}執行結果：
條件變量是C++11提供的另外一種用于等待的同步機制，它能夠阻塞一個或者多個賢臣，直到收到另一個線程發出的通知或者超時，才會喚醒當前阻塞的線程。條件變量需要和互斥量配合起來使用。C++11提供了兩種條件變量：
condition_valuable，配合std::unique<mutex>進行wait操作
condition_valuable_any，和任意帶有lock，unlock語義的mutex搭配使用，比較靈活，但效率比condition_valuable差一些
可以看到condition_valuable_any比condition_valuable更靈活，因為它通用，對所有的鎖都適用，而condition_valuable的性能更好。我們應該根據具體的應用場景來選擇合適的條件變量
條件變量的使用條件如下：
擁有條件變量的線程獲取互斥量
循環檢測某個條件，如果條件不滿足，則阻塞直到條件滿足；如果條件滿足，則向下執行
某個線程滿足條件執行完畢之后調用notify_onc或者notify_all喚醒一個或者所有等待的線程
一個簡單的生產者消費者模型
mutex mtx;
condition_variable_any notEmpty;//沒滿的條件變量
condition_variable_any notFull;//不為空的條件變量
list<string> list_; //緩沖區
const int custom_threads_size = 3;//消費者的數量
const int produce_threads_size = 4;//生產者的數量
const int max_size = 10;
void produce(int i)
{
while (true)
{
lock_guard<mutex> lock(mtx);
notEmpty.wait(mtx, []{
return list_.size() != max_size;
});
stringstream ss;
ss << "生產者" << i << "生產的東西";
list_.push_back(ss.str());
notFull.notify_one();
}
}
void custome(int i)
{
while (true)
{
lock_guard<mutex> lock(mtx);
notFull.wait(mtx, []{
return !list_.empty();
});
cout << "消費者" << i << "消費了 " << list_.front() << endl;
list_.pop_front();
notEmpty.notify_one();
}
}
int main()
{
vector<std::thread> producer;
vector<std::thread> customer;
for (int i = 0; i < produce_threads_size; ++i)
{
producer.emplace_back(produce, i);
}
for (int i = 0; i < custom_threads_size; ++i)
{
customer.emplace_back(custome, i);
}
for (int i = 0; i < produce_threads_size; ++i)
{
producer[i].join();
}
for (int i = 0; i < custom_threads_size; ++i)
{
customer[i].join();
}
return 0;
}在上述案例中，list<string> list_是一個臨界資源，無論是生產者生產數據，還是消費者消費數據，都要往list_中插入數據或者刪除數據，為了防止出現數據競爭或不一致的狀態，導致程序運行出現問題，因為每次操作list_時都需要進行加鎖操作。
當list_沒有滿的情況下，生產者可以生產數據，如果滿了，則會阻塞在條件變量notFull下，需要消費者通過notify_one()隨機喚醒一個生產者。
當list_不為空的情況下。消費者可以消費數據，如果空了，則會阻塞在條件變量notEmpty下，需要生產者通過notify_one()隨機喚醒一個消費者。
以上就是關于“C++11線程、互斥量及條件變量怎么創建”這篇文章的內容，相信大家都有了一定的了解，希望小編分享的內容對大家有幫助，若想了解更多相關的知識內容，請關注億速云行業資訊頻道。
免責聲明：本站發布的內容（圖片、視頻和文字）以原創、轉載和分享為主，文章觀點不代表本網站立場，如果涉及侵權請聯系站長郵箱：is@yisu.com進行舉報，并提供相關證據，一經查實，將立刻刪除涉嫌侵權內容。
