作为学习练习，我只是尝试使用 std::mutex 和 C++ 标准提供的其他一些东西创建一个 Semaphore 类。我的信号量应根据需要允许尽可能多的 readLock()，但是只有在所有读取都解锁后才能获取 writeLock()。

//Semaphore.h
#include <mutex>
#include <condition_variable>

class Semaphore{
public:
    Semaphore();
    void readLock(); //increments the internal counter
    void readUnlock(); //decrements the internal counter
    void writeLock(); //obtains sole ownership.  must wait for count==0 first
    void writeUnlock(); //releases sole ownership.
    int count; //public for debugging
private:
    std::mutex latch;
    std::unique_lock<std::mutex> lk;
    std::condition_variable cv;
};

//Semaphore.cpp
#include "Semaphore.h"
#include <condition_variable>
#include <iostream>

using namespace std;

Semaphore::Semaphore() : lk(latch,std::defer_lock) { count=0; }
void Semaphore::readLock(){ 
    latch.lock();
    ++count;
    latch.unlock();
    cv.notify_all(); //not sure if this needs to be here?
}
void Semaphore::readUnlock(){
    latch.lock();
    --count;
    latch.unlock();
    cv.notify_all(); //not sure if this needs to be here?
}
void Semaphore::writeLock(){
    cv.wait(lk,[this](){ return count==0; }); //why can't std::mutex be used here?
}
void Semaphore::writeUnlock(){ 
    lk.unlock();
    cv.notify_all();
}

我的测试程序会writeLock() 信号量，启动一堆线程，然后释放信号量。紧接着，主线程将再次尝试 writeLock() 信号量。这个想法是，当信号量解锁时，线程将 readLock() 它并阻止主线程执行任何操作，直到它们全部完成。当它们都完成并释放信号量时，主线程可以再次获取访问权限。我知道这不一定会发生，但这是我正在寻找的情况之一。

//Main.cpp
#include <iostream>
#include <thread>
#include "Semaphore.h"

using namespace std;

Semaphore s;

void foo(int n){
    cout << "Thread Start" << endl;
    s.readLock();
    this_thread::sleep_for(chrono::seconds(n));
    cout << "Thread End" << endl;
    s.readUnlock();
}

int main(){
    std::srand(458279);
    cout << "App Launch" << endl;
    thread a(foo,rand()%10),b(foo,rand()%10),c(foo,rand()%10),d(foo,rand()%10);

    s.writeLock();
    cout << "Main has it" << endl;

    a.detach();
    b.detach();
    c.detach();
    d.detach();

    this_thread::sleep_for(chrono::seconds(2));
    cout << "Main released it" << endl;
    s.writeUnlock();

    s.writeLock();
    cout << "Main has it " << s.count << endl;
    this_thread::sleep_for(chrono::seconds(2));
    cout << "Main released it" << endl;
    s.writeUnlock();

    cout << "App End" << endl;

    system("pause"); //windows, sorry
    return 0;
}

程序抛出一个异常，提示“unlock of unowned mutex”。我认为错误在 writeLock() 或 writeUnlock() 中，但我不确定。谁能指出我正确的方向？

编辑:在构造函数中初始化 lk 时缺少 std::defer_lock，但是它没有修复我遇到的错误。如评论中所述，这不是信号量，对于造成的混淆，我深表歉意。重申一下这个问题，这是我得到的输出(括号中的内容只是我的评论，实际上并不在输出中):

App Launch
Thread Start
Thread Start
Main has it
Thread Start
Thread Start
Thread End (what?)
Main released it
f:\dd\vctools\crt_bld\self_x86\crt\src\thr\mutex.c(131): unlock of unowned mutex
Thread End
Thread End
Thread End

最佳答案

这绝对不是“信号量”。

您的 Semaphore 构造函数立即获取了 latch 上的锁，然后您将其解锁两次，因为 writeUnlock() 调用了 lk。 unlock() 和对 writeLock() 的下一次调用尝试等待具有解锁互斥锁的条件变量，这是未定义的行为，然后您对 writeUnlock( ) 尝试解锁未锁定的互斥量，这也是未定义的行为。

你确定构造函数应该立即锁定互斥量吗？我想你想在构造函数中使用 std::defer_lock，然后在 writeLock() 中锁定互斥体。

关于c++ - 使用 std::mutex 实现信号量，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/18878377/