1 mutex();
2 
3 //不支持拷貝構(gòu)造，也不支持移動(dòng)構(gòu)造（有定義拷貝，則無移動(dòng)）
4 mutex(const mutex&) = delete;
5 mutex& operator=(const mutex&) = delete;

1 void lock();

1 void unlock();

bool try_lock();

 1 int g_nResource = 0;
 2 std::mutex _mutex;
 3 void thread_entry()
 4 {
 5     while (1)
 6     {
 7         if (_mutex.try_lock())
 8         {
 9             cout << this_thread::get_id() << " get lock\n";
10             for (int i = 0; i < 10000000; ++i)
11                 g_nResource++;
12             _mutex.unlock();
13             return;
14         }
15         else
16         {
17             cout << this_thread::get_id() << " no get lock\n";
18             this_thread::sleep_for(std::chrono::milliseconds(500));
19         }
20     }
21 }
22 
23 int main()
24 {
25     thread th1(thread_entry);
26     thread th2(thread_entry);
27     th1.join();
28     th2.join();
29     cout << "Result = " << g_nResource << endl;
30 }

131988 get lock
136260 no get lock
136260 get lock
Result = 20000000

std::lock_guard使用RAII手法，在對(duì)象創(chuàng)建時(shí)，自動(dòng)調(diào)用lock函數(shù)，在對(duì)象銷毀時(shí)，自動(dòng)調(diào)用unlock()函數(shù)，從而保證互斥總能被正確解鎖。該類的實(shí)現(xiàn)很簡(jiǎn)單，直接貼源碼：

 1 template <class _Mutex>
 2 class _NODISCARD lock_guard { // class with destructor that unlocks a mutex
 3 public:
 4     using mutex_type = _Mutex;
 5 
 6     explicit lock_guard(_Mutex& _Mtx) : _MyMutex(_Mtx) { // construct and lock
 7         _MyMutex.lock();
 8     }
 9 
10     lock_guard(_Mutex& _Mtx, adopt_lock_t) : _MyMutex(_Mtx) {} // construct but don't lock
11 
12     ~lock_guard() noexcept {
13         _MyMutex.unlock();
14     }
15 
16     lock_guard(const lock_guard&) = delete;
17     lock_guard& operator=(const lock_guard&) = delete;
18 
19 private:
20     _Mutex& _MyMutex;
21 };

std::lock_guard僅提供了構(gòu)造函數(shù)和析構(gòu)函數(shù)，并未提供其他成員函數(shù)。所以，我們只能用該函數(shù)來獲取鎖、釋放鎖。

案例：

1 int g_nResource = 0;
2 std::mutex _mutex;
3 void thread_entry()
4 {
5     lock_guard<mutex> lock(_mutex);
6     for (int i = 0; i < 10000000; ++i)
7         g_nResource++;
8 }

1 std::lock(lhs._mutex, rhs._mutex);    //對(duì)lhs、rhs上鎖
2 std::lock_guard<mutex> lock_a(lhs._mutex, std::adopt_lock);  //不再上鎖
3 std::lock_guard<mutex> lock_b(rhs._mutex, std::adopt_lock);  //不再上鎖

組織和編排代碼以保護(hù)共享數(shù)據(jù)

使用互斥并不是萬能的，一些情況還是可能會(huì)使得共享數(shù)據(jù)遭受破壞。例如：向調(diào)用者返回指針或引用，指向受保護(hù)的共享數(shù)據(jù)，就會(huì)危及共享數(shù)據(jù)安全?；蛘撸陬悆?nèi)部調(diào)用其他外部接口，而該接口需要傳遞受保護(hù)對(duì)象的引用或者指針。例如：

 1 class SomeData
 2 {
 3 public:
 4     void DoSomething() { cout << "do something\n"; }
 5 };
 6 
 7 class Operator
 8 {
 9 public:
10     void process(std::function<void(SomeData&)> func)
11     {
12         std::lock_guard<mutex> lock(_mutex);
13         func(data);     //數(shù)據(jù)外溢
14     }
15 
16 private:
17     SomeData data;
18     mutex _mutex;
19 };
20 
21 void GetDataPtr(SomeData** pPtr, SomeData& data)
22 {
23     *pPtr = &data;
24 }
25 
26 int main()
27 {
28     Operator opt;
29     SomeData* pUnprotected = nullptr;
30     auto abk = [pUnprotected](SomeData& data) mutable
31     {
32         pUnprotected = &data;
33     };
34     opt.process(abk);
35     pUnprotected->DoSomething();  //以無鎖形式訪問本應(yīng)該受到保護(hù)的數(shù)據(jù)
36 }

c++并未提供任何方法解決上面問題，歸根結(jié)底這是我們代碼設(shè)計(jì)的問題，需要牢記：不得向鎖所在的作用域之外傳遞指針和引用，指向受保護(hù)的共享數(shù)據(jù)，無論是通過函數(shù)返回值將它們保存到對(duì)外可見的內(nèi)存，還是將它們作為參數(shù)傳遞給使用者提供的函數(shù)。

 1 void func()
 2 {
 3     stack<int> s;
 4     if (!s.empty())
 5     {
 6         int nValue = s.top();
 7         s.pop();
 8         do_something(nValue);
 9     }
10 }

template<typename T>
class myStack
{
public:
    myStack();
    ~myStack();

    void pop(T& data);        //傳入引用接收數(shù)據(jù)

};

int main()
{
    myStack<DataRes> s;
    DataRes result;
    s.pop(result);
}

 1 class A
 2 {
 3 public:
 4     A(int nValue) : m_nValue(nValue) {}
 5     friend void Swap(A& lhs, A& rhs)
 6     {
 7         if (&lhs == &rhs) return;
 8         lock_guard<mutex> lock_a(lhs._mutex);
 9         lock_guard<mutex> lock_b(rhs._mutex);
10         std::swap(lhs.m_nValue, rhs.m_nValue);
11     }
12 private:
13     int m_nValue;
14     mutex _mutex;
15 };
16 
17 void func(A& lhs, A& rhs)
18 {
19     Swap(lhs, rhs);
20 }
21 
22 int main()
23 {
24     A a1(10);
25     A a2(20);
26     thread th1(func, std::ref(a1), std::ref(a2));  //傳入?yún)?shù)順序不同
27     thread th2(func, std::ref(a2), std::ref(a1));  //傳入?yún)?shù)順序不同
28     th1.join();
29     th2.join();
30 }

 1 class A
 2 {
 3 public:
 4     A(int nValue) : m_nValue(nValue) {}
 5 
 6     friend void Swap(A& lhs, A& rhs)
 7     {
 8         if (&lhs == &rhs) return;
 9         std::lock(lhs._mutex, rhs._mutex);
10         std::lock_guard<mutex> lock_a(lhs._mutex, std::adopt_lock);  //已經(jīng)上鎖，不再加鎖
11         std::lock_guard<mutex> lock_b(rhs._mutex, std::adopt_lock);  //已經(jīng)上鎖，不再加鎖
12         std::swap(lhs.m_nValue, rhs.m_nValue);
13     }
14 
15 private:
16     int m_nValue;
17     mutex _mutex;
18 };

1 scoped_lock<mutex, mutex> lock(lhs._mutex, rhs._mutex);

1 scoped_lock lock(lhs._mutex, rhs._mutex);

unique_lock();
unique_lock(_Mutex&);     //構(gòu)造并調(diào)用lock上鎖
~unique_lock();                //析構(gòu)并調(diào)用unlock解鎖

//構(gòu)造，_Mtx已經(jīng)被鎖，構(gòu)造函數(shù)不在調(diào)用lock
unique_lock(_Mutex&, adopt_lock_t);    

//構(gòu)造，但不對(duì)_Mtx上鎖，需后續(xù)手動(dòng)調(diào)用
unique_lock(_Mutex&, defer_lock_t)

//構(gòu)造，嘗試獲取鎖，不會(huì)造成阻塞
unique_lock(_Mutex&, try_to_lock_t)

//構(gòu)造 + try_lock_shared_for
unique_lock(_Mutex&, const chrono::duration<_Rep, _Period>&);

//構(gòu)造 + try_lock_shared_until
unique_lock(_Mutex&, const chrono::time_point<_Clock, _Duration>&);

unique_lock(unique_lock&& _Other)；    //移動(dòng)構(gòu)造

//若占有則解鎖互斥，并取得另一者的所有權(quán)
unique_lock& operator=(unique_lock&& _Other)；

//無拷貝構(gòu)造
unique_lock(const unique_lock&) = delete;
unique_lock& operator=(const unique_lock&) = delete;

//鎖定關(guān)聯(lián)互斥
void lock();

//解鎖關(guān)聯(lián)互斥
void unlock();

//嘗試鎖定關(guān)聯(lián)互斥，若互斥不可用則返回
bool try_lock();

//試圖鎖定關(guān)聯(lián)的可定時(shí)鎖定 (TimedLockable) 互斥，若互斥在給定時(shí)長中不可用則返回
bool try_lock_for(const chrono::duration<_Rep, _Period>&);

//嘗試鎖定關(guān)聯(lián)可定時(shí)鎖定 (TimedLockable) 互斥，若抵達(dá)指定時(shí)間點(diǎn)互斥仍不可用則返回
bool try_lock_until(const chrono::time_point<_Clock, _Duration>&);

//與另一 std::unique_lock 交換狀態(tài)
void swap(unique_lock& _Other);

//將關(guān)聯(lián)互斥解關(guān)聯(lián)而不解鎖它
 _Mutex* release();

//測(cè)試是否占有其關(guān)聯(lián)互斥
bool owns_lock();

//同owns_lock
operator bool();

//返回指向關(guān)聯(lián)互斥的指針
_Mutex* mutex();

 1 std::mutex _Mtx;
 2 
 3 void PrepareData() {}
 4 
 5 void DoSomething() {}
 6 
 7 std::unique_lock<std::mutex> get_lock()
 8 {
 9     std::unique_lock<std::mutex> lock(_Mtx);
10     PrepareData();
11     return lock;
12 }
13 
14 void ProcessData()
15 {
16     std::unique_lock<std::mutex> lock(get_lock());
17     DoSomething();
18 }

 1 std::mutex _Mtx;
 2 bool GetAndProcessData()
 3 {
 4     std::unique_lock<std::mutex> lock(_Mtx);
 5     DataResource data = GetData();
 6     lock.unlock();
 7     bool bResult = WirteToFile(data);    //非常耗時(shí)
 8     lock.lock();
 9     SaveResult(bResult);
10     return bResult;
11 }

 1 class Y
 2 {
 3 private:
 4     int some_detail;
 5     mutable std::mutex m;
 6     int get_detail() const
 7     {
 8         std::lock_guard<std::mutex> lock_a(m);
 9         return some_detail;
10     }
11 public:
12     Y(int sd):some_detail(sd){}
13     friend bool operator==(Y const& lhs, Y const& rhs)
14     {
15         if(&lhs==&rhs)
16             return true;
17         int const lhs_value=lhs.get_detail();    
18         int const rhs_value=rhs.get_detail();   
19         return lhs_value==rhs_value;    ?---  ④
20     }
21 };

保護(hù)共享數(shù)據(jù)的其他工具

互斥是保護(hù)共享數(shù)據(jù)的最普遍的方式之一，但它并非唯一方式。

在初始化過程中保護(hù)共享數(shù)據(jù)

假設(shè)我們需要某個(gè)共享數(shù)據(jù)，而它創(chuàng)建起來開銷不菲。因?yàn)閯?chuàng)建它可能需要建立數(shù)據(jù)庫連接或分配大量?jī)?nèi)存，所以等到必要時(shí)才真正著手創(chuàng)建。這種方式稱為延遲初始化（lazy initialization）。最常見的就是實(shí)現(xiàn)懶漢式單例模式，現(xiàn)在，時(shí)代變了，實(shí)現(xiàn)線程安全的單例模式，不需要使用雙重鎖了！

std::call_once()函數(shù)與std::once_flag

std::call_once()函數(shù)可以確?？烧{(diào)用對(duì)象僅執(zhí)行一次，即使是在并發(fā)訪問下。該函數(shù)定義如下：

1 template <class _Fn, class... _Args>
2 void(call_once)(once_flag& _Once, _Fn&& _Fx, _Args&&... _Ax)；

• _Once：std::once_flag對(duì)象，它確保僅有一個(gè)線程能執(zhí)行函數(shù)。
• _Fx：待調(diào)用的可調(diào)用對(duì)象。
• _Ax：傳遞給可調(diào)用對(duì)象的參數(shù)包。

用std::call_once()函數(shù)實(shí)現(xiàn)單例：

 1 class Singleton
 2 {
 3 public:
 4     static Singleton* Ins()
 5     {
 6         std::call_once(_flag, []() {
 7             _ins = new Singleton;
 8         });
 9         return _ins;
10     }
11 
12     Singleton(const Singleton&) = delete;
13     Singleton& operator=(const Singleton&) = delete;
14 
15 protected:
16     Singleton() { std::cout << "constructor" << std::endl; }
17     ~Singleton() { std::cout << "destructor" << std::endl; }    //必須聲明為私有，否則返回指針將可析構(gòu)
18 
19 private:
20     struct Deleter
21     {
22         ~Deleter() {
23             delete _ins;
24             _ins = nullptr;
25         }
26     };
27     static Deleter _deleter;
28     static Singleton* _ins;
29     static std::once_flag _flag;
30 };
31 
32 Singleton::Deleter Singleton::_deleter;
33 Singleton* Singleton::_ins = nullptr;
34 std::once_flag Singleton::_flag;

Deleter確保Singleton對(duì)象銷毀時(shí)，能夠釋放_ins對(duì)象。

 1 class Singleton
 2 {
 3 public:
 4     static Singleton& Ins()
 5     {
 6         static Singleton _ins;
 7         return _ins;
 8     }
 9 
10     Singleton(const Singleton&) = delete;
11     Singleton& operator=(const Singleton&) = delete;
12 
13 protected:
14     Singleton() { std::cout << "constructor" << std::endl; }
15     ~Singleton() { std::cout << "destructor" << std::endl; }
16 };

保護(hù)甚少更新的數(shù)據(jù)結(jié)構(gòu)

考慮一個(gè)存儲(chǔ)著DNS條目的緩存表，它將域名解釋成對(duì)應(yīng)的IP地址。給定的DNS條目通常在很長時(shí)間內(nèi)都不會(huì)變化——在許多情況下，DNS條目保持多年不變。盡管，隨著用戶訪問不同網(wǎng)站，緩存表會(huì)不時(shí)加入新條目，但在很大程度上，數(shù)據(jù)在整個(gè)生命期內(nèi)將保持不變。為了判斷數(shù)據(jù)是否有效，必須定期查驗(yàn)緩存表；只要細(xì)節(jié)有所改動(dòng)，就需要進(jìn)行更新。

更新雖然鮮有，但它們還是會(huì)發(fā)生。另外，如果緩存表被多線程訪問，更新過程就需得到妥善保護(hù)，以確保各個(gè)線程在讀取緩存表時(shí)，全都見不到失效數(shù)據(jù)。

如果使用傳統(tǒng)的互斥，效率可能不高：當(dāng)更新緩存表時(shí)，阻止其他線程訪問數(shù)據(jù)是理所應(yīng)到。但很多時(shí)候，數(shù)據(jù)未發(fā)生改變，但每個(gè)線程讀取數(shù)據(jù)都會(huì)導(dǎo)致上鎖，即讀多寫少，std::mutex效率就比較低了。

C++17標(biāo)準(zhǔn)庫提供了兩種新的互斥：std::shared_mutex和std::shared_timed_mutex。

std::shared_mutex

• 平臺(tái)：c++17
• 頭文件：?<shared_mutex>?

std::shared_mutex類可用于保護(hù)共享數(shù)據(jù)不被多個(gè)線程同時(shí)訪問。與獨(dú)占式互斥不同，該類擁有兩種訪問級(jí)別：

• 共享 - 多個(gè)線程能共享同一互斥的所有權(quán)。
• 獨(dú)占性 - 僅一個(gè)線程能占有互斥。

std::shared_mutex有如下特點(diǎn)：

• 若一個(gè)線程已獲得獨(dú)占鎖（通過lock、try_lock）則無其他線程能獲取該鎖（包括共享的）。
• 僅當(dāng)任何線程均未獲取獨(dú)占性鎖時(shí)，共享鎖才能被多個(gè)線程獲?。ㄍㄟ^lock_shared 、try_lock_shared）。
• 在一個(gè)線程內(nèi)，同一時(shí)刻只能獲取一個(gè)鎖（共享或獨(dú)占性）。

構(gòu)造函數(shù)

shared_mutex();     //構(gòu)造互斥
~shared_mutex();    //析構(gòu)互斥

//無拷貝
shared_mutex(const shared_mutex&) = delete;
shared_mutex& operator=(const shared_mutex&) = delete;

void lock();        //鎖定互斥，若互斥不可用則阻塞
void unlock();      //解鎖互斥
void try_lock();    //嘗試鎖定互斥，若互斥不可用則返回

void lock_shared();        //為共享所有權(quán)鎖定互斥，若互斥不可用則阻塞
bool try_lock_shared();    //嘗試為共享所有權(quán)鎖定互斥，若互斥不可用則返回
void unlock_shared();      //解鎖共享所有權(quán)互斥

 1 std::shared_mutex _Mtx;
 2 void func()
 3 {
 4     _Mtx.lock_shared();
 5     cout << " thread Id = " << this_thread::get_id() << " do something!\n";
 6     _Mtx.unlock_shared();
 7 }
 8 
 9 int main()
10 {
11     _Mtx.lock_shared();    //使用共享鎖鎖住
12     thread th1(func);
13     thread th2(func);
14     th1.join();
15     th2.join();
16     _Mtx.unlock_shared();
17 }

shared_timed_mutex();
~shared_timed_mutex();

shared_timed_mutex(const shared_timed_mutex&) = delete;
shared_timed_mutex& operator=(const shared_timed_mutex&) = delete;

void lock();        //鎖定互斥，若互斥不可用則阻塞
void unlock();      //解鎖互斥
bool try_lock();    //嘗試鎖定互斥，若互斥不可用則返回

//嘗試鎖定互斥，若互斥在指定的時(shí)限時(shí)期中不可用則返回
bool try_lock_for(const chrono::duration<_Rep, _Period>&);

//嘗試鎖定互斥，若直至抵達(dá)指定時(shí)間點(diǎn)互斥不可用則返回
bool try_lock_until(const chrono::time_point<_Clock, _Duration>&)

void lock_shared();        //為共享所有權(quán)鎖定互斥，若互斥不可用則阻塞
bool try_lock_shared();    //嘗試為共享所有權(quán)鎖定互斥，若互斥不可用則返回
void unlock_shared();      //解鎖互斥（共享所有權(quán)）

//嘗試為共享所有權(quán)鎖定互斥，若互斥在指定的時(shí)限時(shí)期中不可用則返回
bool try_lock_shared_for(const chrono::duration<_Rep, _Period>&);

//嘗試為共享所有權(quán)鎖定互斥，若直至抵達(dá)指定時(shí)間點(diǎn)互斥不可用則返回
bool try_lock_shared_until(const chrono::time_point<_Clock, _Duration>&);

shared_lock();
shared_lock(mutex_type&);     //構(gòu)造并調(diào)用lock_shared上鎖
~shared_lock()；              //析構(gòu)并調(diào)用unlock_shared解鎖

//構(gòu)造，但不對(duì)_Mtx上鎖，需后續(xù)手動(dòng)調(diào)用
shared_lock(mutex_type&, defer_lock_t)

//構(gòu)造，嘗試獲取鎖，不會(huì)造成阻塞
shared_lock(mutex_type&, try_to_lock_t)

//構(gòu)造，_Mtx已經(jīng)被鎖，構(gòu)造函數(shù)不在調(diào)用lock
shared_lock(mutex_type&, adopt_lock_t)

//構(gòu)造 + try_lock_shared_for
shared_lock(mutex_type&, const chrono::duration<_Rep, _Period>&)

//構(gòu)造 + try_lock_shared_until
shared_lock(mutex_type&, const chrono::time_point<_Clock, _Duration>&)

shared_lock(shared_lock&&);      //移動(dòng)構(gòu)造
shared_lock& operator=(shared_lock&&);    //移動(dòng)賦值，會(huì)先解鎖

//鎖定關(guān)聯(lián)的互斥
void lock();

//嘗試鎖定關(guān)聯(lián)的互斥
bool try_lock();

//解鎖關(guān)聯(lián)的互斥
void unlock();

//嘗試鎖定關(guān)聯(lián)的互斥，以指定時(shí)長
try_lock_for(const chrono::duration<_Rep, _Period>&);

//嘗試鎖定關(guān)聯(lián)的互斥，直至指定的時(shí)間點(diǎn)
bool try_lock_until(const chrono::time_point<_Clock, _Duration>&);

//解除關(guān)聯(lián) mutex 而不解鎖
mutex_type* release();

//測(cè)試鎖是否占有其關(guān)聯(lián)的互斥
bool owns_lock();

//同owns_lock
operator bool();

//返回指向關(guān)聯(lián)的互斥的指針
mutex_type* mutex();

//與另一 shared_lock 交換數(shù)據(jù)成員
void swap(shared_lock& _Right)

 1 class A
 2 {
 3 public:
 4     A& operator=(const A& other)
 5     {
 6         //上獨(dú)占鎖（寫操作）
 7         unique_lock<shared_mutex> lhs(_Mtx, defer_lock);            
 8 
 9         //上共享鎖（讀操作）
10         shared_lock<shared_mutex> rhs(other._Mtx, defer_lock);        
11 
12         //上鎖
13         lock(lhs, rhs);            
14 
15         to_do_assignment();      //賦值操作
16         return *this;
17     }
18 private:
19     mutable std::shared_mutex _Mtx;
20 };

遞歸加鎖

假如線程已經(jīng)持有某個(gè)std::mutex實(shí)例，試圖再次對(duì)其重新加鎖就會(huì)出錯(cuò)，將導(dǎo)致未定義行為。但在某些場(chǎng)景中，確有需要讓線程在同一互斥上多次重復(fù)加鎖，而無須解鎖。C++標(biāo)準(zhǔn)庫為此提供了std::recursive_mutex，其工作方式與std::mutex相似，不同之處是，其允許同一線程對(duì)某互斥的同一實(shí)例多次加鎖。我們必須先釋放全部的鎖，才可以讓另一個(gè)線程鎖住該互斥。例如，若我們對(duì)它調(diào)用了3次lock()，就必須調(diào)用3次unlock()。只要正確地使用std::lock_guard<std::recursive_mutex>和std::unique_lock<std::recursive_mutex>，它們便會(huì)處理好遞歸鎖的余下細(xì)節(jié)。

工作中盡量避免使用遞歸鎖，這可能是一種拙劣的設(shè)計(jì)，換一種方式，可能用普通鎖就解決問題了。比如，提取一個(gè)新的函數(shù)，在外部先加鎖，然后遞歸調(diào)用該函數(shù)。

Copyright

本文參考至《c++并發(fā)編程實(shí)戰(zhàn)》 第二版，作者：安東尼·威廉姆斯。本人閱讀后添加了自己的理解并整理，方便后續(xù)查找，可能存在錯(cuò)誤，歡迎大家指正，感謝！文章來源地址http://www.zghlxwxcb.cn/news/detail-709759.html