Question

首先，我想指出我已经看过这个但却无法找到我正在寻找/已经与过于详细的答案混淆的答案。

我有一个使用两个线程的程序。需要在线程A中设置和读取布尔值，但只能在线程B中读取。

主题A：

Module::Module(){
}

void Module::foo(){
    mutex.lock();
    bool request = true;
    mutex.unlock();
}

void Module::bar(){
    mutex.lock();
    if (request){
        mutex.unlock();
        // do stuff
    }else{
        mutex.unlock();
    }
}

主题B：

Provider::Provider(){
    module = new Module;  // pointer to class request 'lives in'
}

void Provider::foo(){
    mutex.lock();
    if (module->request){
        mutex.unlock();
        // do stuff
        }
    }else{
        mutex.unlock();
    }
}

我的问题似乎相当微不足道，但它让我感到烦恼。线程A不能同时读写，因此我认为A不需要递归互斥。但是，foo（）和bar（）很可能同时从线程B调用（信号和时隙）。这是否意味着我需要递归互斥？

也;有没有理由不使用Qt :: BlockingQueudConnection？一位同事认为这是危险的，因为它会在调用执行插槽之前将调用线程发送到睡眠状态 - 但这与mutex不同吗？

此外;看过关于构造互斥体的帖子（pthread mutex locking variables used in statements）。在这里，它提到了在价值观上制作本地副本。如果我要为线程A使用类似的东西，例如

mutex.lock();
requestCopy = request;
mutex.lock();
...
if(requestCopy){
// do stuff
}

这会阻止requestCopy被使用时访问请求吗？我想在我的代码中使用这种样式以简化，但如果你在一个线程中读取和写入，这将不起作用？

任何帮助都会很棒。

Answer 1

从你所展示的，它看起来像（重写）

某个模块（线程A）：

class Module {
private:
    bool request = false;
    QMutex m;
public:    
    void set_request(bool b) {
        QMutexLocker lock(&m);
        request = b;
    }

    bool get_request() {
        QMutexLocker lock(&m);
        return request;
    }

    void bar() {
        if (get_request()) {
            // do stuff
        }
    }
};

主题B：

class Provider {
public:
    Provider() {
        module = new Module();
    }

    void foo() {
        if (module->get_request()){
            // do stuff
        }
    }
private:
    Module *module;
};

如果确实如此（这样一切都很好），就不需要递归互斥。

Qt / C ++：递归互斥，＆＃39;同步区＆＃39;并阻止信号

1 个答案: