多執行緒程式設計的鎖問題解析（鎖競爭死鎖活鎖及Date Race等）

load [%counter], rax; // 執行緒1從counter讀取0到暫存器rax
add rax, 1; // 執行緒1對暫存器rax進行加1
load [%counter], rbx; // 執行緒2從counter讀取0到暫存器rbx
store rax [%counter]; // 執行緒1把1寫入counter的主存地址
add rbx, 1; // 執行緒2對暫存器rbx進行加1
store rbx, [%counter]; // 執行緒2把1寫入counter的主存地址

#include <iostream>
#include <thread>
#include <mutex>
#include <vector>
#include <algorithm>

int counter = 0;
std::mutex mt; 

void thread_task()
{
//  mt.lock();
    for(int i=0; i<1000; ++i)
        counter++;
//  mt.unlock();
}

int main()
{
    std::vector<std::thread> workers;
    for(int i=0; i<5; ++i){
        auto t = std::thread(thread_task);
        workers.push_back(std::move(t));
    }   
    std::for_each(workers.begin(), workers.end(), std::mem_fn(&std::thread::join));
    std::cout<<counter<<std::endl;
    return 0;
}

// 執行緒 1                     
void func1()                    
{                       
    LOCK(&mutex_a);                      
    LOCK(&mutex_b);//執行緒1停滯在此         
    counter++;                       
    UNLOCK(&mutex_b);                     
    UNLOCK(&mutex_a);                    
}                       
 
// 執行緒 2
void func2()
{
    LOCK(&mutex_b);
    LOCK(&mutex_a);//執行緒2停滯在此
    counter++;
    UNLOCK(&mutex_a);
    UNLOCK(&mutex_b);
}

// 執行緒 1                     
void func1()                    
{                       
LOCK(&mutex_a);                      
...                     
func_call1();                
UNLOCK(&mutex_a);                
}                       
 
func_call1()                    
{                       
   LOCK(&mutex_b);               
   ...                       
   UNLOCK(&mutex_b);                 
   ...                       
}                       
 
// 執行緒 2
void func2()
{
    LOCK(&mutex_b);
    ...
    func_call2()
    UNLOCK(&mutex_b);
}
 
func_call2()
{
    LOCK(&mutex_a);
    ...
    UNLOCK(&mutex_b);
    ...
}

#include <iostream>
#include <unistd.h>
#include <thread>
#include <mutex>
#include <vector>
#include <algorithm>

int counter = 0;
std::mutex mt_1;
std::mutex mt_2;

void thread_task1()
{
    mt_1.lock();
    sleep(1);    //review the deadlock
    mt_2.lock();
    counter++;
    mt_2.unlock();
    mt_1.unlock();
}

void thread_task2()
{
    mt_2.lock();
    sleep(1);
    mt_1.lock();
    counter++;
    mt_1.unlock();
    mt_2.unlock();
}

int main()
{
    std::thread t1(thread_task1);
    std::thread t2(thread_task2);
    t1.join();
    t2.join();
    return 0;
}

// 執行緒 1                     
void func1()                    
{                       
    int done = 0;                   
    while(!done) {               
        LOCK(&mutex_a);                      
        if (TRYLOCK(&mutex_b)) {               
            counter++;                   
            UNLOCK(&mutex_b);                        
            UNLOCK(&mutex_a);                        
            done = 1;                        
        }                          
        else {                     
            UNLOCK(&mutex_a);                   
        }                          
    }                        
}                       
 
// 執行緒 2
void func2()
{
    int done = 0;
    while(!done) {
        LOCK(&mutex_b);
        if (TRYLOCK(&mutex_a)) {
            counter++;
            UNLOCK(&mutex_a);
            UNLOCK(&mutex_b);
            done = 1; 
        }
        else {
            UNLOCK(&mutex_b);
        }
    }
}

#include <iostream>
#include <unistd.h>
#include <thread>
#include <mutex>
#include <vector>
#include <algorithm>
#include <functional>
#include <chrono>

int counter = 0;
std::mutex mutex_1;
std::mutex mutex_2;

void thread_task1()
{
    int done = 0;
    while(!done){
        mutex_1.lock();
        if(mutex_2.try_lock()) {//return -1 on success
            counter++;
            mutex_2.unlock();
            mutex_1.unlock();
            done = 1;
        }   
        else{
            std::cout<<"is task 1 alive?"<<std::endl;
            mutex_1.unlock();
        }   
    }   
}

void thread_task2()
{
    int done = 0;
    while(!done){
        mutex_2.lock();
        if(mutex_1.try_lock()){
            counter++;
            mutex_1.unlock();
            mutex_2.unlock();
            done = 1;
        }
        else{
            std::cout<<"is task 2 alive?"<<std::endl;
            mutex_2.unlock();
        }
    }
}

int main()
{
    std::thread t1(thread_task1);
    std::thread t2(thread_task2);
    t1.join();
    t2.join();
    return 0;
}

3. 鎖競爭效能瓶頸

3.1阿姆達爾法則（Amdahl’s Law）

  總體執行時間T = S + P/N

#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <unistd.h>

thread_local int counter = 0;
std::mutex mt; 

void thread_task(const std::string& thread_name)
{
    ++counter;
    {   
        std::lock_guard<std::mutex> lock(mt);
        std::cout<<"counter for "<<thread_name<<" :"<<counter<<std::endl;
    }   
}

int main()
{
    std::thread t1(thread_task, "t1");
    std::thread t2(thread_task, "t2");
    
    {   
        std::lock_guard<std::mutex> lock(mt);
        std::cout<<"counter for main: "<<counter<<std::endl;  //注意同步cout，因為一個語句多次向緩衝區寫，期間不能有其他執行緒寫入
    }   

    t1.join();
    t2.join();

    return 0;
}

輸出：

3.2.2 使用讀寫鎖