與信號量的Threadsafe單例問題

Question

我已經寫了一個簡單的單例應用程序。

以下是我的樣本主類

// ThreadsafeSingletonUsingSemaphore.cpp : Defines the entry point for the console application. 
// 

#include "stdafx.h" 
#include <iostream> 
#include <conio.h> 
#include "MySingleton.h" 
using namespace std; 

int i =0; 
#define THREADCOUNT 100 
DWORD WINAPI ThreadProc(LPVOID lParam); 
HANDLE g_semaphore = NULL; 

int _tmain(int argc, _TCHAR* argv[]) 
{ 
    g_semaphore = CreateSemaphore(NULL,1,1,_T("TreadOne")); 
    HANDLE hThread[THREADCOUNT]; 
    DWORD aThreadID; 

    for(int iCount = 0; iCount < THREADCOUNT ; iCount++) 
    { 
     hThread[iCount] = CreateThread(NULL, 0, ThreadProc, 0,0, &aThreadID); 
     if(hThread[iCount] == NULL) 
     { 
      cout<<"CreateThread error: %d" << GetLastError() << endl; 
      return 1; 
     } 
    } 

    WaitForMultipleObjects(THREADCOUNT, hThread, TRUE, INFINITE); 

    // Close thread and semaphore handles 
    for(int i=0; i < THREADCOUNT; i++) 
     CloseHandle(hThread[i]); 

    cout << MySingleton::getInstance().getCounter() << endl ; 

    CloseHandle(g_semaphore); 
    _getch(); 
    return 0; 
} 

DWORD WINAPI ThreadProc(LPVOID lpParam) 
{ 
    //DWORD result = WaitForSingleObject(g_semaphore,INFINITE); 
    //if(WAIT_OBJECT_0 == result) 
     MySingleton::getInstance().incrementCouner(); 
    //ReleaseSemaphore(g_semaphore,1, NULL); 
    return TRUE; 
} 

這是我的單身實現類。

#include "StdAfx.h" 
#include "MySingleton.h" 

MySingleton* MySingleton::m_instance = NULL; 
HANDLE MySingleton::m_hSem = CreateSemaphore(NULL, 1, 1, _T("MySingleton")); 
HANDLE MySingleton::m_One = CreateSemaphore(NULL, 1, 1, _T("MyOne")); 

MySingleton::MySingleton(void) : m_counter(0) 
{ 
} 

MySingleton::~MySingleton(void) 
{ 
    cout << "destructor" << endl; 
    CloseHandle(m_hSem); 
    CloseHandle(m_One); 
} 

MySingleton& MySingleton::getInstance() 
{ 
    DWORD result = WaitForSingleObject(m_hSem, INFINITE); 

    if(WAIT_OBJECT_0 == result) 
    { 
     if(m_instance == NULL) 
     { 
      cout << "creating" << endl; 
      m_instance = new MySingleton(); 
     } 
    } 
    ReleaseSemaphore(m_hSem,1,NULL); 
    return *m_instance; 
} 

void MySingleton::setCouner(int iCount_in) 
{ 
    m_counter = iCount_in; 
} 
int MySingleton::getCounter() 
{ 
    return m_counter; 
} 

void MySingleton::incrementCouner() 
{ 
    DWORD result = WaitForSingleObject(m_One, INFINITE); 
    if(WAIT_OBJECT_0 == result) 
     m_counter++; 
    ReleaseSemaphore(m_One,1,NULL); 
} 

這是我的.h類。

#pragma once 
#include <windows.h> 
#include <iostream> 
#include <conio.h> 
using namespace std; 

class MySingleton 
{ 
private: 
    static HANDLE m_hSem, m_One; 
    HANDLE m_hCountSem; 
    static MySingleton* m_instance; 
    int m_counter; 
    MySingleton(); 
    MySingleton(const MySingleton& obj_in); 
    MySingleton& operator=(const MySingleton& obj_in); 
public: 
    ~MySingleton(void); 

    static MySingleton& getInstance(); 
    void setCouner(int iCount_in); 
    int getCounter(); 

    void incrementCouner(); 
}; 

的問題是反的最終值是從來沒有100有人可以解釋我爲什麼，什麼是我做wrong.I我無法理解的問題。當我在創建每個線程之前在主體中引入睡眠時，它可以正常工作。

Answer 1

的問題是，調用WaitForMultipleObjects句柄MAXIMUM_WAIT_OBJECTS了其中，至少在Visual Studio 2017年，是64

通知您到WaitForMultipleObjects呼叫如何加入線程返回WAIT_FAILED。

爲了等待一個應該多個對象，according to the documentation：

要等待超過MAXIMUM_WAIT_OBJECTS處理更多，請使用下列方法之一：

• 創建一個線程等待MAXIMUM_WAIT_OBJECTS處理，然後等待該線程加上其他句柄。使用這種技術將句柄分成MAXIMUM_WAIT_OBJECTS組。
• 調用RegisterWaitForSingleObject在每個句柄上等待。線程池中的等待線程等待MAXIMUM_WAIT_OBJECTS註冊對象，並在對象發出信號或超時間隔到期後分配工作線程。

Answer 2

你不需要編寫所有的代碼。實現線程單身的最簡單方法是使用斯科特·邁爾的單成語：

class Singleton { 
    int counter; 
    mutable std::mutex counter_guard; 
    Singleton() {} 
public: 
    Singleton(const Singleton&) = delete; 
    Singleton(Singleton&&) = delete; 
    Singleton& operator=(const Singleton&) = delete; 
    Singleton& operator=(Singleton&&) = delete; 

    static Singleton& instance() { 
     static Singleton theInstance; 
     return theInstance; 
    } 

    void setCounter(int newVal) { 
     std::unique_lock<std::mutex> lock(counter_guard); 
     counter = newVal; 
    } 
    void incrementCounter() { 
     std::unique_lock<std::mutex> lock(counter_guard); 
     ++counter; 
    } 
    int getCounter() const { 
     std::unique_lock<std::mutex> lock(counter_guard); 
     return counter; 
    } 
}; 

---

更簡單的方法是使用一個std::atomic<int>型爲counter成員變量。那麼互斥鎖和鎖守可以完全省略。