winapi를 통한 Mutex 와 std::recursive_mutex를 통한 동기화 차이

// MutexTest.cpp: 콘솔 응용 프로그램의 진입점을 정의합니다.
//
 
#include "stdafx.h"
 
#include <iostream>
#include <Windows.h>
#include <thread>
#include <mutex>
 
#include <time.h>
 
int g_index = 1000;
 
int operateCount = 0;
 
#include <list>
 
 
static std::recursive_mutex rMutex;
 
void Increase(HANDLE hMutex) {
    std::unique_lock<std::recursive_mutex> lock(rMutex, std::defer_lock); // 초기화 시간을 제외하기 위해
 
    for (int i = 0; i < 100000; i++) {
        WaitForSingleObject(hMutex, INFINITE);
        //g_index++;
 
        operateCount++;
        
        
        ReleaseMutex(hMutex);
    }
 
}
 
void Decrease(HANDLE hMutex) {
    std::unique_lock<std::recursive_mutex> lock(rMutex, std::defer_lock); // 초기화 시간을 제외하기 위해
 
    for (int i = 0; i < 100000; i++) {
        WaitForSingleObject(hMutex, INFINITE);
        
        operateCount++;
        
 
        ReleaseMutex(hMutex);
    }
}
 
 
//static std::recursive_mutex rMutex;
 
//std::unique_lock<std::recursive_mutex> lock(rMutex, std::defer_lock);
 
void Increase2() {
    std::unique_lock<std::recursive_mutex> lock(rMutex, std::defer_lock);
 
    for (int i = 0; i < 100000; i++){
 
        lock.lock();
        operateCount++;
 
 
        lock.unlock();
    }
 
}
 
void Decrease2() {
 
    std::unique_lock<std::recursive_mutex> lock(rMutex, std::defer_lock);
    for (int i = 0; i < 100000; i++) {
        lock.lock();
        operateCount++;
        lock.unlock();
    }
 
}
 
 
 
static std::chrono::system_clock::time_point start;
 
int main()
{
 
    HANDLE hMutex = CreateMutex(NULL, FALSE, NULL);
    
    //std::unique_lock<std::recursive_mutex> lock(rMutex, std::defer_lock);
 
    //매개 변수로 넘기려고 했으나,, 복제가 안된다고 한다
 
    /*
        CreateMutex VS unique_lock을 통한 recursiveMutex의

        시간 차이를 비교해 본결 과,

        전자는 대략 1초

        후자는 대략 0.08초가 걸렸다.

        즉 시간차이는 10배 이상 차이가 난다.

        전자는 좀 더 세밀한 동기화를 위해 필요하고

        후자는 세밀한 동기화가 필요없고 원자성만 보장하고 싶을 때

        사용하는 것이 적합할 것 같다.
    
    */
    
    start = std::chrono::system_clock::now();
 
//    std::thread t1(Increase, hMutex);
//    std::thread t2(Decrease, hMutex);
 
 
    std::thread t1(Increase2);
    std::thread t2(Decrease2);
 
    t1.join();
    t2.join();
 
    std::chrono::duration<double> sec = std::chrono::system_clock::now() - start;
 
    std::cout << "수행 시간 : " << sec.count() << std::endl;
    //std::chrono::seconds duration(1);
    //std::this_thread::sleep_for(duration);
    
    printf("operate Count : %d\n", operateCount);
    
    getchar();
    return 0;
}
 
 

recursive_mutex 와 winapi를 통해 만드는 mutex와  둘 중에 뭘 쓸까 고민하다가

비교를 해보기로 했다.

결과는 코드에 써있다.  

CreateMutex VS unique_lock을 통한 recursiveMutex의

시간 차이를 비교해 본결 과,

전자는 대략 1초

후자는 대략 0.08초가 걸렸다.

즉 시간차이는 10배 이상 차이가 난다.

전자는 좀 더 세밀한 동기화를 위해 필요하고

후자는 세밀한 동기화가 필요없고 원자성만 보장하고 싶을 때

사용하는 것이 적합할 것 같다.