2. 程式人生 > >C++ 併發程式設計之互斥鎖和條件變數的效能比較

C++ 併發程式設計之互斥鎖和條件變數的效能比較

阿新 • • 發佈：2019-09-01

介紹

本文以最簡單生產者消費者模型，通過執行程式，觀察該程序的cpu使用率，來對比使用互斥鎖 和 互斥鎖+條件變數的效能比較。

本例子的生產者消費者模型，1個生產者，5個消費者。
生產者執行緒往佇列裡放入資料，5個消費者執行緒從佇列取資料，取資料前需要判斷一下佇列中是否有資料，這個佇列是全域性佇列，是執行緒間共享的資料，所以需要使用互斥鎖進行保護。即生產者在往佇列裡放入資料時，其餘消費者不能取，反之亦然。

互斥鎖實現的程式碼

#include <iostream> // std::cout
#include <deque>    // std::deque
#include <thread>   // std::thread
#include <chrono>   // std::chrono
#include <mutex>    // std::mutex


// 全域性佇列
std::deque<int> g_deque;

// 全域性鎖
std::mutex g_mutex;

// 生產者執行標記
bool producer_is_running = true;

// 生產者執行緒函式
void Producer()
{
    // 庫存個數
    int count = 8;
    
    do
    {
        // 智慧鎖，初始化後即加鎖，保護的範圍是程式碼花括號內，花括號退出即會自動解鎖
        // 可以手動解鎖，從而控制互斥鎖的細粒度
        std::unique_lock<std::mutex> locker( g_mutex );
        // 入隊一個數據
        g_deque.push_front( count );
        // 提前解鎖，縮小互斥鎖的細粒度，只針對共享的佇列資料進行同步保護
        locker.unlock(); 

        std::cout << "生產者    ：我現在庫存有 :" << count << std::endl;
            
        // 放慢生產者生產速度，睡1秒
        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );

        // 庫存自減少
        count--;
    } while( count > 0 );
    
    // 標記生產者打樣了
    producer_is_running = false;

    std::cout << "生產者    ： 我的庫存沒有了，我要打樣了！"  << std::endl;
}

// 消費者執行緒函式
void Consumer(int id)
{
    int data = 0;

    do
    {
        std::unique_lock<std::mutex> locker( g_mutex );
        if( !g_deque.empty() )
        {
            data = g_deque.back();
            g_deque.pop_back();
            locker.unlock();

            std::cout << "消費者[" << id << "] : 我搶到貨的編號是 :" << data << std::endl;
        }
        else
        {
            locker.unlock();
        }
    } while( producer_is_running );
    
    std::cout << "消費者[" << id << "] ：賣家沒有貨打樣了，真可惜，下次再來搶！"  << std::endl;
}

int main(void)
{
    std::cout << "1 producer start ..." << std::endl;
    std::thread producer( Producer );

    std::cout << "5 consumer start ..." << std::endl;
    std::thread consumer[ 5 ];
    for(int i = 0; i < 5; i++)
    {
        consumer[i] = std::thread(Consumer, i + 1);
    }

    producer.join();

    for(int i = 0; i < 5; i++)
    {
        consumer[i].join();
    }

    std::cout << "All threads joined." << std::endl;

    return 0;
}

互斥鎖實現執行結果：

結果輸出

[root@lincoding condition]# g++ -std=c++0x -pthread -D_GLIBCXX_USE_NANOSLEEP main.cpp -o  main
[root@lincoding condition]# ./main
1 producer start ...
5 consumer start ...
生產者    ：我現在庫存有 :8
消費者[1] : 我搶到貨的編號是 :8
消費者[1] : 我搶到貨的編號是 :7
生產者    ：我現在庫存有 :7
生產者    ：我現在庫存有 :6
消費者[3] : 我搶到貨的編號是 :6
生產者    ：我現在庫存有 :5
消費者[1] : 我搶到貨的編號是 :5
生產者    ：我現在庫存有 :4
消費者[2] : 我搶到貨的編號是 :4
生產者    ：我現在庫存有 :3
消費者[5] : 我搶到貨的編號是 :3
生產者    ：我現在庫存有 :2
消費者[2] : 我搶到貨的編號是 :2
生產者    ：我現在庫存有 :1
消費者[1] : 我搶到貨的編號是 :1
生產者    ： 我的庫存沒有了，我要打樣了！消費者[
5] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[2] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[3] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[4] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[1] ：賣家沒有貨打樣了，真可惜，下次再來搶！
All threads joined.

可以看到，互斥鎖其實可以完成這個任務，但是卻存在著效能問題。

  • Producer是生產者執行緒，在生產者資料過程中，會休息1秒，所以這個生產過程是很慢的；

  • Consumer是消費者執行緒，存在著一個while迴圈，只有判斷到生產者不運行了，才會退出while迴圈，那麼每次在迴圈體內，都是會先加鎖，判斷佇列不空，然後從列隊取出一個數據，最後解鎖。所以說，在生產者休息1秒的時候，消費者執行緒實際上會做很多無用功，導致CPU使用率非常高！

執行的環境是4核cpu

[root@lincoding ~]# grep 'model name' /proc/cpuinfo | wc -l
4

top命令檢視cpu使用情況，可見使用純互斥鎖cpu的開銷是很大的，main

程序的cpu使用率達到了357.5%CPU，系統開銷的cpu為54.5%sy，使用者開銷的cpu為18.2%us

[root@lincoding ~]# top
top - 19:13:41 up 36 min,  3 users,  load average: 0.06, 0.05, 0.01
Tasks: 179 total,   1 running, 178 sleeping,   0 stopped,   0 zombie
Cpu(s): 18.2%us, 54.5%sy,  0.0%ni, 27.3%id,  0.0%wa,  0.0%hi,  0.0%si,  0.0%st
Mem:   1004412k total,   313492k used,   690920k free,    41424k buffers
Swap:  2031608k total,        0k used,  2031608k free,    79968k cached

   PID USER      PR  NI  VIRT  RES  SHR S %CPU %MEM    TIME+  COMMAND                                                                                                                       
 35346 root      20   0  137m 3288 1024 S 357.5  0.3   0:05.92 main                                                                                                                          
     1 root      20   0 19232 1492 1224 S  0.0  0.1   0:02.16 init                                                                                                                           
     2 root      20   0     0    0    0 S  0.0  0.0   0:00.01 kthreadd                                                                                                                       
     3 root      RT   0     0    0    0 S  0.0  0.0   0:00.68 migration/0

解決的辦法之一就是給消費者也加一個小延時，當消費者沒取到資料時，就休息一下500毫秒，這樣可以減少互斥鎖給cpu帶來的開銷。

// 消費者執行緒函式
void Consumer(int id)
{
    int data = 0;

    do
    {
        std::unique_lock<std::mutex> locker( g_mutex );
        if( !g_deque.empty() )
        {
            data = g_deque.back();
            g_deque.pop_back();
            locker.unlock();

            std::cout << "消費者[" << id << "] : 我搶到貨的編號是 :" << data << std::endl;
        }
        else
        {
            locker.unlock();
            // 當消費者沒取到資料時，就休息一下500毫秒
            std::this_thread::sleep_for( std::chrono::milliseconds( 500 ) );
        }
    } while( producer_is_running );
    
    std::cout << "消費者[" << id << "] ：賣家沒有貨打樣了，真可惜，下次再來搶！"  << std::endl;
}

從執行結果可知，cpu使用率大大降低了

[root@lincoding ~]# ps aux | grep -v grep  |grep main
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      61296  0.0  0.1 141068  1244 pts/1    Sl+  19:40   0:00 ./main

條件變數+互斥鎖實現的程式碼

那麼問題來了，如何確定消費者延時（休息）多久呢？

  • 如果生產者生產的非常快，消費者卻延時了500毫秒，也不是很好
  • 如果生產者生產的更慢，那麼消費延時500毫秒，也會有無用功，佔用了CPU

這就需要引入條件變數std::condition_variable，應用於消費者生產模型中，就是生產者生產完一個數據後，通過notify_one()喚醒正在wait()消費者執行緒，使得消費者從佇列取出一個數據。

#include <iostream> // std::cout
#include <deque>    // std::deque
#include <thread>   // std::thread
#include <chrono>   // std::chrono
#include <mutex>    // std::mutex

#include <condition_variable> // std::condition_variable


// 全域性佇列
std::deque<int> g_deque;

// 全域性鎖
std::mutex g_mutex;

// 全域性條件變數
std::condition_variable g_cond;

// 生產者執行標記
bool producer_is_running = true;

// 生產者執行緒函式
void Producer()
{
    // 庫存個數
    int count = 8;
    
    do
    {
        // 智慧鎖，初始化後即加鎖，保護的範圍是程式碼花括號內，花括號退出即會自動解鎖
        // 可以手動解鎖，從而控制互斥鎖的細粒度
        std::unique_lock<std::mutex> locker( g_mutex );
        // 入隊一個數據
        g_deque.push_front( count );
        // 提前解鎖，縮小互斥鎖的細粒度，只針對共享的佇列資料進行同步保護
        locker.unlock(); 

        std::cout << "生產者    ：我現在庫存有 :" << count << std::endl;
        
        // 喚醒一個執行緒
        g_cond.notify_one();
        
        // 睡1秒
        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );

        // 庫存自減少
        count--;
    } while( count > 0 );
    
    // 標記生產者打樣了
    producer_is_running = false;
    
    // 喚醒所有消費執行緒
    g_cond.notify_all();
    
    std::cout << "生產者    ： 我的庫存沒有了，我要打樣了！"  << std::endl;
}

// 消費者執行緒函式
void Consumer(int id)
{
    // 購買的貨品編號
    int data = 0;

    do
    {
        // 智慧鎖，初始化後即加鎖，保護的範圍是程式碼花括號內，花括號退出即會自動解鎖
        // 可以手動解鎖，從而控制互斥鎖的細粒度
        std::unique_lock<std::mutex> locker( g_mutex );
        
        // wait()函式會先呼叫互斥鎖的unlock()函式，然後再將自己睡眠，在被喚醒後，又會繼續持有鎖，保護後面的佇列操作
        // 必須使用unique_lock，不能使用lock_guard，因為lock_guard沒有lock和unlock介面，而unique_lock則都提供了
        g_cond.wait(locker); 
        
        // 佇列不為空
        if( !g_deque.empty() )
        {
            // 取出佇列裡最後一個數據
            data = g_deque.back();
            
            // 刪除佇列裡最後一個數據
            g_deque.pop_back();
            
            // 提前解鎖，縮小互斥鎖的細粒度，只針對共享的佇列資料進行同步保護
            locker.unlock(); 

            std::cout << "消費者[" << id << "] : 我搶到貨的編號是 :" << data << std::endl;
        }
        // 佇列為空
        else
        {
            locker.unlock();
        }
    
    } while( producer_is_running );
    
    std::cout << "消費者[" << id << "] ：賣家沒有貨打樣了，真可惜，下次再來搶！"  << std::endl;
}

int main(void)
{
    std::cout << "1 producer start ..." << std::endl;
    std::thread producer( Producer );

    std::cout << "5 consumer start ..." << std::endl;
    std::thread consumer[ 5 ];
    for(int i = 0; i < 5; i++)
    {
        consumer[i] = std::thread(Consumer, i + 1);
    }

    producer.join();

    for(int i = 0; i < 5; i++)
    {
        consumer[i].join();
    }

    std::cout << "All threads joined." << std::endl;

    return 0;
}

條件變數+互斥鎖執行結果

[root@lincoding condition]# g++ -std=c++0x -pthread -D_GLIBCXX_USE_NANOSLEEP main.cpp -o  main
[root@lincoding condition]# 
[root@lincoding condition]# ./main 
1 producer start ...
5 consumer start ...
生產者    ：我現在庫存有 :8
消費者[4] : 我搶到貨的編號是 :8
生產者    ：我現在庫存有 :7
消費者[2] : 我搶到貨的編號是 :7
生產者    ：我現在庫存有 :6
消費者[3] : 我搶到貨的編號是 :6
生產者    ：我現在庫存有 :5
消費者[5] : 我搶到貨的編號是 :5
生產者    ：我現在庫存有 :4
消費者[1] : 我搶到貨的編號是 :4
生產者    ：我現在庫存有 :3
消費者[4] : 我搶到貨的編號是 :3
生產者    ：我現在庫存有 :2
消費者[2] : 我搶到貨的編號是 :2
生產者    ：我現在庫存有 :1
消費者[3] : 我搶到貨的編號是 :1
生產者    ： 我的庫存沒有了，我要打樣了！
消費者[5] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[1] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[4] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[2] ：賣家沒有貨打樣了，真可惜，下次再來搶！
消費者[3] ：賣家沒有貨打樣了，真可惜，下次再來搶！
All threads joined.

CPU開銷非常的小

[root@lincoding ~]# ps aux | grep -v grep  |grep main
USER        PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
root      73838  0.0  0.1 141068  1256 pts/1    Sl+  19:54   0:00 ./main

總結

在不確定生產者的生產速度是快還是慢的場景裡，不能只使用互斥鎖保護共享的資料，這樣會對CPU的效能開銷非常大，可以使用互斥鎖+條件變數的方式，當生產者執行緒生產了一個數據，就喚醒消費者執行緒進行消費，避免一些無用功的效能開銷

相關推薦

C++ 併發程式設計之互斥鎖和條件變數的效能比較

介紹 本文以最簡單生產者消費者模型，通過執行程式，觀察該程序的cpu使用率，來對比使用互斥鎖 和 互斥鎖+條件變數的效能比較。 本例子的生產者消費者模型，1個生產者，5個消費者。 生產者執行緒往佇列裡放入資料，5個消費者執行緒從佇列取資料，取資料前需要判斷一下佇列中是否有資料，這個佇列是全域性佇列，是執行緒間

【Java併發程式設計】之二十：併發新特性—Lock鎖和條件變數（含程式碼）

簡單使用Lock鎖     Java 5中引入了新的鎖機制——java.util.concurrent.locks中的顯式的互斥鎖：Lock介面，它提供了比synchronized更加廣泛的鎖定操作。Lock介面有3個實現它的類：ReentrantLock、Reetrant

c++併發程式設計之thread::join()和thread::detach()

thread::join(): 阻塞當前執行緒，直至 *this 所標識的執行緒完成其執行。*this 所標識的執行緒的完成同步於從 join() 的成功返回。 該方法簡單暴力，主執行緒等待子程序期間什麼都不能做。thread::join()會清理子執行緒相關的記憶體空間，

【Linux C 多執行緒程式設計】互斥鎖與條件變數

一、互斥鎖互斥量從本質上說就是一把鎖, 提供對共享資源的保護訪問。　　1. 初始化:　　在Linux下, 執行緒的互斥量資料型別是pthread_mutex_t. 在使用前, 要對它進行初始化:　　對於靜態分配的互斥量, 可以把它設定為PTHREAD_MUTEX_INITIA

Linux C互斥鎖和條件變數（POSIX標準）

       與程序類似，執行緒也存在同步的問題，當多個控制執行緒共享相同的記憶體時，需要確保每個執行緒看到一致的資料檢視，如果每個執行緒使用的變數都是其他執行緒不會讀取或修改的（比如執行緒私有資料），就不會存在一致性問題。通常來說使用者可以使用互斥量（互斥鎖）或者的條件變數

Linux下多執行緒程式設計互斥鎖和條件變數的簡單使用

Linux下的多執行緒遵循POSIX執行緒介面，稱為pthread。編寫Linux下的多執行緒程式，需要使用標頭檔案pthread.h，連結時需要使用庫libpthread.a。執行緒是程序的一個實體，是CPU排程和分派的基本單位，它是比程序更小的能獨立執行的基本單位。執行緒

linux下用互斥鎖和條件變數來實現讀寫鎖

以下內容來源自UNP卷二的第八章 讀寫鎖的概念( the conception of read-write lock ) (1)只要沒有執行緒持有某個給定的讀寫鎖用於寫，那麼任意數目的執行緒可以持有該執行緒用於讀 (2)僅當沒有執行緒持有某個給定的讀寫鎖用於讀或用於寫，才能分配該

通過互斥鎖和條件變數實現佇列的無sleep生產與消費

昨天轉了一篇文章將條件變數與互斥鎖的結合使用，今天給大家摳出曾經學到的一段高效的處理訊息的demo，通過互斥鎖實現安全佇列，通過條件變數實現佇列的工作與休息。 目錄結構： 簡單介紹： SignalThread是封裝好的執行緒類，我們所做的核心工作都是在這裡完成，其他類也是服務於這裡；

執行緒私有資料TSD——一鍵多值技術，執行緒同步中的互斥鎖和條件變數

一：執行緒私有資料： 執行緒是輕量級程序，程序在fork()之後，子程序不繼承父程序的鎖和警告，別的基本上都會繼承，而vfork()與fork()不同的地方在於vfork()之後的程序會共享父程序的地址空間，但是有了寫實複製（fork()之後的子程序也不會直接

Linux使用互斥鎖和條件變數實現讀寫鎖（寫優先）

（1）只要沒有執行緒持有某個給定的讀寫鎖用於寫，那麼任意數目的執行緒可以持有該讀寫鎖用於讀（2）僅當沒有執行緒持有某個讀寫鎖用於讀或用於寫時，才能分配該讀寫鎖用於寫換一種說法就是，只要沒有執行緒在修改（寫）某個給定的資料，那麼任意數目的執行緒都可以擁有該資料的訪問權（讀）。僅

Linux程序通訊[2]-互斥鎖和條件變數

概述 上一篇介紹了共享記憶體，已經屬於比較高階的層次。本篇介紹一下多執行緒/多程序最基礎的問題，同步。 為了允許線上程或程序間共享資料，同步常常是必需的，也就是我們常說要用鎖（當然鎖通常也是效能瓶頸，現在無鎖架構正在越發流行）。互斥鎖和條件變數則是同步的基本組成部分。互斥鎖和條件變數在同一程序下的所有

C++11 thread 及互斥鎖、條件變數

啟動的格式： #include <thread>//包含標頭檔案 void fucntion();//定義一個執行緒執行的函式 thread t1(fucntion);//執行緒啟

多執行緒用互斥鎖和條件變數實現生產者和消費者-------迴圈任務佇列

互斥鎖與條件變數簡介 在多執行緒的環境中，全域性變數會被各執行緒共享，因此在操作全域性變數的時候需要採用鎖機制，在linux裡最常用的鎖就是互斥鎖，互斥鎖使用方法如下 <pre name="code" class="cpp">//執行緒A pthread_mut

Linux多執行緒消費者和生產者模型例項（互斥鎖和條件變數使用）

條件變數簡單介紹： 條件變數是執行緒可以使用的另一種同步機制。條件變數與互斥量一起使用的時候，允許執行緒以無競爭的方式等待特定的條件發生。條件本身是由互斥量保護的。執行緒在改變條件變數狀態前必須先鎖住互斥量。另一種是動態分配的條件變數，則用pthread_cond_ini

Linux多執行緒程式設計---執行緒間同步（互斥鎖、條件變數、訊號量和讀寫鎖）

本篇博文轉自http://zhangxiaoya.github.io/2015/05/15/multi-thread-of-c-program-language-on-linux/ Linux下提供了多種方式來處理執行緒同步，最常用的是互斥鎖、條件變數、訊號量和讀寫鎖。  下面是思維導

互斥鎖和條件變量(pthread)相關函數

code 數據類型 wait 模式 truct color tro val initial 互斥鎖 #include <pthread.h> // 若成功返回0，出錯返回正的Exxx值 // mptr通常被初始化為PTHREAD_MUTEX_INITIALI

python網路程式設計之互斥鎖

標籤（空格分隔）： 互斥鎖 程序之間的資料不共享，但是共享同一套檔案系統，所以訪問同一個檔案，或者同一個列印終端，是沒有問題的，而共享帶來的問題就是競爭，競爭帶來的結果就是錯亂，如下： #併發執行,效率高,但競爭同一列印終端,帶來了列印錯亂 from multiprocessing import Pr

Java併發程式設計之Locks鎖

Java併發程式設計：Lock 此文轉載自：  　　http://www.cnblogs.com/dolphin0520/p/3923167.html 　　從Java 5之後，在java.util.concurrent.locks包下提供了另外一種方式來實現同

java併發程式設計之顯示鎖

顯示鎖 為了保證共享物件的安全性，常用的機制有: volatile 關鍵字 synchronized ReentrantLock 顯示鎖 1.1 ReentrantLock ReentrantLock實現了Lock介面。Lock介面定義一組抽象的

洞悉C++網路程式設計之tcp/ip和socket api

原文地址：https://blog.csdn.net/libaineu2004/article/details/79020403 TCP(Transmission Control Protocol)　傳輸控制協議 三次握手 TCP是主機對主機層的傳輸控制協議，提供可靠的連線服務，採用三次