c ++自己实现信号量

Question

让我们假设没有为 C++ 提供信号量的库。我是这样写的：

#include <vector>
#include <Windows.h>

class Semaphore {
    HANDLE mutexS;                  //  provides mutex in semaphore rutines
    std::vector<HANDLE> queue;      //  provides FIFO queue for blocked threads
    int value;                      //  semaphore's value

public:
    Semaphore(int init=1);  
    ~Semaphore();

    void wait();
    void signal();
};


Semaphore::Semaphore(int init) {
    value = init;
    queue = std::vector<HANDLE>();
    mutexS = CreateMutex(0,0,0);
}

Semaphore::~Semaphore() {
    CloseHandle(mutexS);
}




void Semaphore::signal() {
    WaitForSingleObject(mutexS, INFINITE);
    if (++value <= 0) {
        HANDLE someOldThread = queue.front();
        ResumeThread(someOldThread);
        queue.erase(queue.begin());
        CloseHandle(someOldThread);
    }
    ReleaseMutex(mutexS);
}

我想知道为什么这个 wait() 的实现不起作用：

void Semaphore::wait() {
    WaitForSingleObject(mutexS, INFINITE);

    if (--value < 0) {
        HANDLE thisThread = GetCurrentThread();   
        queue.push_back(thisThread);
        ReleaseMutex(mutexS);
        SuspendThread(thisThread );
    }
    else
        ReleaseMutex(mutexS);
}

这一个有效：

void Semaphore::wait() {
    WaitForSingleObject(mutexS, INFINITE);

    if (--value < 0) {
        HANDLE thisThread = GetCurrentThread();
        HANDLE alsoThisThread;

        DuplicateHandle(GetCurrentProcess(), thisThread, GetCurrentProcess(), &alsoThisThread, 0, 0, DUPLICATE_SAME_ACCESS);

        queue.push_back(alsoThisThread);

        ReleaseMutex(mutexS);

        SuspendThread(alsoThisThread);
    }
    else
        ReleaseMutex(mutexS);
}

每种情况下究竟发生了什么？很长时间以来，我一直在努力解决它。等待的第一个实现，它不起作用，使我的程序阻塞（嗯，它可能永远阻塞一些线程）。第二个实现就像一个魅力。是什么赋予了 ？为什么我需要复制线程句柄并阻止重复？

Answer 1

MSDN 在这里有很大帮助 ;)

GetCurrentThread 返回一个伪句柄，它是“当前线程”的常量：

伪句柄是一个特殊的常量，被解释为当前线程句柄。

因此，当您将其推送到队列中时，您总是推送一个表示“当前线程”的常量，这显然不是您想要的。

要获得真正的句柄，你必须使用DuplicateHandle

如果 hSourceHandle 是 GetCurrentProcess 或 GetCurrentThread 返回的伪句柄，DuplicateHandle 会将其分别转换为进程或线程的真实句柄。

最后一点：我想你是把它作为一个“测试”来实现的，对吧？因为有几个潜在的问题。一个很好的学习练习就是把它们挖出来。但是你不应该在生产代码中使用它。

出于好奇：如果您想进行更多实验，使用互斥锁实现信号量的“规范”方式是使用两个互斥锁：see here

Answer 2

MSDN documentation for GetCurrentThread 有答案（口音是我的）：

返回值是当前线程的伪句柄。

伪句柄是解释为当前线程句柄的特殊常量。每当需要线程句柄时，调用线程可以使用此句柄来指定自己。

...

该函数不能被一个线程使用来创建一个句柄，该句柄可以被其他线程用来引用第一个线程。 句柄总是被解释为引用正在使用它的线程。通过在调用 DuplicateHandle 函数时将伪句柄指定为源句柄，线程可以为自己创建一个“真实”句柄，供其他线程使用或由其他进程继承。