Qt/C++: Recursive mutex, 'sync zones' and blocking signals

Question

Firstly I'd like to point out that I've looked this up but can't find the answer I'm looking for/have got confused with overly detailed answers.

I have a program which uses two threads. A Boolean values need to be set and read in Thread A but only read in Thread B.

Thread 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();
    }
} 

Thread 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();
    }
}

My question might seem rather trivial, but it's bugged me. Thread A cannot read and write at the same time, thus i'd argue recursive mutex is not required for A. However, there is a small possibility foo() and bar() could get called simultaneous from Thread B (Signals and slots). Does this mean I need recursive mutex?

Also; is there any reason not to use a Qt::BlockingQueudConnection? A colleague argued that this is dangerous as it sends calling threads to sleep until the signal has executed the slot- but is this not sort of the same as mutex?

Furthermore; seen a post regarding structuring mutex (pthread mutex locking variables used in statements). In here it mentions making local copies on values. If i was to employ something similar for Thread A e.g.

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

Will this also block access of request whereever requestCopy is getting used? I was looking to use this style in my code for simplicity but this would not work if you read AND write in a thread?

Any help would be great.

Answer 1

From what you have shown, it looks like (rewritten)

Some module (Thread 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
        }
    }
};

Thread B:

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

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

If this is really the case (and everything is fine this way), there is no need for a recursive mutex.