Back to Qt.io
Contact Us Blog Download Qt
Sur cette page

QMutexLocker Class

template <typename Mutex> class QMutexLocker

La classe `QMutexLocker` est une classe utilitaire qui simplifie le verrouillage et le déverrouillage des mutex. En savoir plus...

En-tête : #include <QMutexLocker>
CMake : find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake : QT += core

Remarque : toutes les fonctions de cette classe sont sûres pour les threads.

Fonctions publiques

QMutexLocker(Mutex *mutex)
(since 6.4) QMutexLocker(QMutexLocker<Mutex> &&other)
~QMutexLocker()
(since 6.4) bool isLocked() const
Mutex *mutex() const
void relock()
(since 6.4) void swap(QMutexLocker<Mutex> &other)
void unlock()
(since 6.4) QMutexLocker<Mutex> &operator=(QMutexLocker<Mutex> &&other)

Description détaillée

QMutexLocker est une classe de modèle dont le paramètre de modèle Mutex spécifie le type de mutex (tel que QMutex ou QRecursiveMutex) à verrouiller et déverrouiller.

Le verrouillage et le déverrouillage d’un QMutex ou d’un QRecursiveMutex dans des fonctions et des instructions complexes ou dans du code de gestion des exceptions sont sources d’erreurs et difficiles à déboguer. QMutexLocker peut être utilisé dans de telles situations pour garantir que l’état du mutex est toujours bien défini.

QMutexLocker doit être créé au sein d’une fonction dans laquelle un QMutex doit être verrouillé. Le mutex est verrouillé lors de la création de QMutexLocker. Vous pouvez déverrouiller et reverrouiller le mutex à l’aide de unlock() et relock(). S’il est verrouillé, le mutex sera déverrouillé lors de la destruction de QMutexLocker.

Par exemple, cette fonction complexe verrouille un ` QMutex ` à l’entrée de la fonction et le déverrouille à tous les points de sortie :

int complexFunction(int flag)
{
    mutex.lock();

    int retVal = 0;

    switch (flag) {
    case 0:
    case 1:
        retVal = moreComplexFunction(flag);
        break;
    case 2:
        {
            int status = anotherFunction();
            if (status < 0) {
                mutex.unlock();
                return -2;
            }
            retVal = status + flag;
        }
        break;
    default:
        if (flag > 10) {
            mutex.unlock();
            return -1;
        }
        break;
    }

    mutex.unlock();
    return retVal;
}

Cette fonction d'exemple deviendra plus complexe au fur et à mesure de son développement, ce qui augmente le risque d'erreurs.

L'utilisation de QMutexLocker simplifie considérablement le code et le rend plus lisible :

int complexFunction(int flag)
{
    QMutexLocker locker(&mutex);

    int retVal = 0;

    switch (flag) {
    case 0:
    case 1:
        return moreComplexFunction(flag);
    case 2:
        {
            int status = anotherFunction();
            if (status < 0)
                return -2;
            retVal = status + flag;
        }
        break;
    default:
        if (flag > 10)
            return -1;
        break;
    }

    return retVal;
}

Désormais, le mutex sera toujours déverrouillé lorsque l’objet `QMutexLocker` sera détruit (lorsque la fonction retournera, puisque ` locker ` est une variable `auto`).

Le même principe s’applique au code qui lève et intercepte des exceptions. Une exception qui n’est pas interceptée dans la fonction ayant verrouillé le mutex ne peut en aucun cas déverrouiller celui-ci avant que l’exception ne soit remontée dans la pile jusqu’à la fonction appelante.

QMutexLocker fournit également une fonction membre ` mutex() ` qui renvoie le mutex sur lequel le QMutexLocker opère. Cela est utile pour le code qui a besoin d’accéder au mutex, comme ` QWaitCondition::wait()`. Par exemple :

class SignalWaiter
{
private:
    QMutexLocker<QMutex> locker;

public:
    SignalWaiter(QMutex *mutex)
        : locker(mutex)
    {
    }

    void waitForSignal()
    {
        //...
        while (!signalled)
            waitCondition.wait(locker.mutex());
        //...
    }
};

Voir également QReadLocker, QWriteLocker et QMutex.

Documentation sur les fonctions membres

[explicit noexcept(...)] QMutexLocker::QMutexLocker(Mutex *mutex)

Crée un objet `QMutexLocker` et verrouille ` mutex`. Le mutex sera déverrouillé lorsque l'objet `QMutexLocker` sera détruit. Si ` mutex ` est égal à ` nullptr`, `QMutexLocker` ne fait rien.

Remarque : cette fonction est de type « noexcept » lorsque ` LockIsNoexcept ` est ` true`.

Voir également QMutex::lock().

[noexcept, since 6.4] QMutexLocker::QMutexLocker(QMutexLocker<Mutex> &&other)

Construit par « move » un objet `QMutexLocker` à partir de ` other`. Le mutex et l'état de ` other ` sont transférés à la nouvelle instance construite. Après le déplacement, ` other ` ne gérera plus aucun mutex.

Cette fonction a été introduite dans Qt 6.4.

Voir également QMutex::lock().

QMutexLocker::~QMutexLocker()

Détruit l'QMutexLocker et déverrouille le mutex qui avait été verrouillé dans le constructeur.

Voir aussi QMutex::unlock().

[noexcept, since 6.4] bool QMutexLocker::isLocked() const

Renvoie « true » si cette instance de ` QMutexLocker ` est en train de verrouiller le mutex qui lui est associé, ou « false » dans le cas contraire.

Cette fonction a été introduite dans Qt 6.4.

Mutex *QMutexLocker::mutex() const

Renvoie le mutex sur lequel l'QMutexLocker e est en cours d'exécution.

[noexcept(...)] void QMutexLocker::relock()

Verrouille à nouveau un mutex déverrouillé.

Remarque : cette fonction est de type « noexcept » lorsque LockIsNoexcept est défini sur true.

Voir également unlock().

[noexcept, since 6.4] void QMutexLocker::swap(QMutexLocker<Mutex> &other)

Permute le mutex et l'état de cette QMutexLocker avec other. Cette opération est très rapide et ne rencontre jamais d'échec.

Cette fonction a été introduite dans Qt 6.4.

Voir également QMutex::lock().

[noexcept] void QMutexLocker::unlock()

Déverrouille ce mutex. Vous pouvez utiliser la fonction ` relock() ` pour le verrouiller à nouveau. Il n'est pas nécessaire de le verrouiller lors de sa destruction.

Voir également relock().

[noexcept, since 6.4] QMutexLocker<Mutex> &QMutexLocker::operator=(QMutexLocker<Mutex> &&other)

La fonction « move » affecte other à cet objet QMutexLocker. Si cet objet QMutexLocker détenait un mutex verrouillé avant l'affectation, celui-ci sera déverrouillé. Le mutex et l'état de other sont ensuite transférés à cet objet QMutexLocker. Après le déplacement, other ne gérera plus aucun mutex.

Cette fonction a été introduite dans Qt 6.4.

Voir également QMutex::lock().

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.