带有信号量的线程安全单例问题

Question

我写了一个简单的单例应用程序。

以下是我的主要示例class

// 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;
}

这是我的单例实现 class。

#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 class。

#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 我无法理解这个问题。当我在创建每个线程之前在 main 中引入睡眠时，它工作正常。

Answer 1

您不需要编写所有这些代码。实现线程安全单例的最简单方法是使用 Scott Meyer 的单例惯用语：

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;
    }  
};

一种更简单的方法是为 counter 成员变量使用 std::atomic<int> 类型。那么mutex和lock guards就完全可以省略了

Answer 2

问题是对 WaitForMultipleObjects 的调用最多处理 MAXIMUM_WAIT_OBJECTS，至少在 Visual Studio 2017 年是 64。

请注意您如何调用 WaitForMultipleObjects 加入线程 returns WAIT_FAILED。

为了等待更多的对象，according to the documentation:

To wait on more than MAXIMUM_WAIT_OBJECTS handles, use one of the following methods:

Create a thread to wait on MAXIMUM_WAIT_OBJECTS handles, then wait on that thread plus the other handles. Use this technique to break the handles into groups of MAXIMUM_WAIT_OBJECTS.

Call RegisterWaitForSingleObject to wait on each handle. A wait thread from the thread pool waits on MAXIMUM_WAIT_OBJECTS registered objects and assigns a worker thread after the object is signaled or the time-out interval expires.

带有信号量的线程安全单例问题

issue with Threadsafe singleton with semaphore

c++

multithreading

semaphore