QMutex doit-il être statique pour que les autres threads qui appellent cette instance de classe sachent qu'ils doivent suspendre leurs opérations ?

Question

La fonction append suivante est appelée à partir de plusieurs threads. Je ne veux pas que les données réécrivent un append parce que le compteur n'a pas encore été incrémenté.

Est-ce que cela va suspendre tous les fils qui arrivent, sauf celui qui utilise actuellement Append ? Ou les autres threads continueront-ils à fonctionner et n'ajouteront-ils pas les données ?

Le mutex doit-il être "STATIQUE" ou chaque instance saura-t-elle suspendre ses opérations ?

Si je ne veux pas de hoquets, je suppose que je dois construire un tampon pour sauvegarder les données ?

void classA::Append(int _msg)
{
    static int c = 0;
    QMutex mutex; //need to be static so other threads know to suspend?
                  //there are 10 threads creating an instantiation of classA or an object of classA     

    mutex.lock();

    intArray[c] = _msg;
    c++;

    mutex.unlock();
}

Answer 1

Non, ça n'a pas besoin d'être static il suffit d'en faire un membre dans votre classA et vous pouvez également jeter un coup d'œil à QMutexLocker pour verrouiller et déverrouiller le mutex :

void classA::Append(int _msg)
{
    static int c = 0;
    QMutexLocker locker(&mutex); // mutex is a QMutex member in your class

    intArray[c] = _msg;
    c++;

    /*mutex.unlock(); this unlock is not needed anymore, because QMutexLocker unlocks the mutex when the locker scope ends, this very useful especially if you have conditional and return statements in your function*/
}

Answer 2

Le QMutex n'a pas besoin d'être déclaré comme statique et Qt s'assure que les autres threads attendent que le déverrouillage se produise sur le mutex avant de permettre à un autre thread de poursuivre l'exécution de cette fonction.

Answer 3

Pour résoudre mon problème, après plusieurs exécutions, j'ai dû rendre mutex "Statique" en raison des multiples instanciations de classA. Faire de mutex un membre n'a pas fonctionné.

void classA::Append(int _msg)
{
    static int c = 0;
    static QMutex mutex; //YES... need to be static so other threads know to suspend
                         //there are 10 threads creating an instantiation of classA or an object of classA     

    mutex.lock();

    intArray[c] = _msg;
    c++;

    mutex.unlock();
}

Answer 4

@jdl "Making mutex a member did not work". Oui, cela fonctionne. Essayez de rendre mutex "Static" comme ceci :

//classA.h
class ClassA {
    public:
        static QMutex mutex;
        // rest of variables and Methods
        // ...
}

//classA.cpp
QMutex ClassA::mutex; // Before all
ClassA::ClassA() {
    //Constructor
}
void ClassA::Append(int _msg) {
    static int c = 0
    QMutexLocker locker(&mutex)
    intArray[c] = _msg;
    c++;
}

Answer 5

Comme je ne sais pas comment fonctionne réellement QMutex, j'ai simplement créé mon propre mutex.

void classA::Append(int _msg)
{
    static int c = 0;
    static int mutex = 0; //YES... need to be static so other threads know to suspend
                     //there are 10 threads creating an instantiation of classA or an object of classA     

    while(mutex == 1){
        //suspend thread
    }

    if(mutex == 0){
        mutex = 1;//lock        

        intArray[c] = _msg;
        c++;

        mutex = 0;//unlock
    }

}