Back to Qt.io
Contact Us Blog Download Qt
Auf dieser Seite

QMutexLocker Class

template <typename Mutex> class QMutexLocker

Die Klasse „QMutexLocker“ ist eine Hilfsklasse, die das Sperren und Entsperren von Mutexen vereinfacht. Mehr...

Header: #include <QMutexLocker>
CMake: find_package(Qt6 REQUIRED COMPONENTS Core)
target_link_libraries(mytarget PRIVATE Qt6::Core)
qmake: QT += core

Hinweis: Alle Funktionen dieser Klasse sind threadsicher.

Öffentliche Funktionen

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)

Ausführliche Beschreibung

QMutexLocker ist eine Template-Klasse, bei der der Template-Parameter „ Mutex “ den Mutex-Typ (z. B. „ QMutex “ oder „ QRecursiveMutex “) angibt, der gesperrt und entsperrt werden soll.

Das Sperren und Entsperren eines ` QMutex ` oder ` QRecursiveMutex ` in komplexen Funktionen und Anweisungen oder in Code zur Ausnahmebehandlung ist fehleranfällig und schwer zu debuggen. QMutexLocker kann in solchen Situationen verwendet werden, um sicherzustellen, dass der Zustand des Mutex stets eindeutig definiert ist.

Ein `QMutexLocker` sollte innerhalb einer Funktion erstellt werden, in der ein ` QMutex ` gesperrt werden muss. Der Mutex wird bei der Erstellung des `QMutexLocker` gesperrt. Mit ` unlock() ` und ` relock()` können Sie den Mutex entsperren und erneut sperren. Ist der Mutex gesperrt, wird er beim Zerstören des `QMutexLocker` entsperrt.

Beispielsweise sperrt diese komplexe Funktion einen ` QMutex ` beim Eintritt in die Funktion und entsperrt den Mutex an allen Ausstiegspunkten:

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;
}

Diese Beispielfunktion wird im Laufe der Entwicklung immer komplexer, was die Wahrscheinlichkeit erhöht, dass Fehler auftreten.

Die Verwendung von `QMutexLocker` vereinfacht den Code erheblich und macht ihn lesbarer:

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;
}

Nun wird der Mutex immer dann entsperrt, wenn das QMutexLocker-Objekt zerstört wird (wenn die Funktion zurückkehrt, da ` locker ` eine `auto`-Variable ist).

Das gleiche Prinzip gilt für Code, der Ausnahmen auslöst und abfängt. Eine Ausnahme, die in der Funktion, die den Mutex gesperrt hat, nicht abgefangen wird, kann den Mutex nicht mehr entsperren, bevor die Ausnahme den Stack hinauf an die aufrufende Funktion weitergeleitet wird.

QMutexLocker stellt außerdem eine Memberfunktion ` mutex() ` bereit, die den Mutex zurückgibt, auf dem der `QMutexLocker` arbeitet. Dies ist nützlich für Code, der Zugriff auf den Mutex benötigt, wie beispielsweise ` QWaitCondition::wait()`. Zum Beispiel:

class SignalWaiter
{
private:
    QMutexLocker<QMutex> locker;

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

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

Siehe auch „ QReadLocker “, „ QWriteLocker “ und „ QMutex “.

Dokumentation zu den Mitgliedsfunktionen

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

Erstellt einen `QMutexLocker` und sperrt ` mutex`. Der Mutex wird entsperrt, wenn der `QMutexLocker` zerstört wird. Wenn ` mutex ` gleich ` nullptr` ist, führt der `QMutexLocker` keine Aktion aus.

Hinweis: Diese Funktion ist „noexcept“, wenn LockIsNoexcept gleich true ist.

Siehe auch QMutex::lock().

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

Erstellt mithilfe eines „move“-Konstruktors einen QMutexLocker aus „ other “. Der Mutex und der Status von „ other “ werden auf die neu erstellte Instanz übertragen. Nach dem Move verwaltet „ other “ keinen Mutex mehr.

Diese Funktion wurde in Qt 6.4 eingeführt.

Siehe auch ` QMutex::lock()`.

QMutexLocker::~QMutexLocker()

Löscht das „ QMutexLocker “ und gibt den Mutex frei, der im Konstruktor gesperrt wurde.

Siehe auch ` QMutex::unlock()`.

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

Gibt „true“ zurück, wenn dieses „ QMutexLocker “ derzeit den zugehörigen Mutex sperrt, andernfalls „false“.

Diese Funktion wurde in Qt 6.4 eingeführt.

Mutex *QMutexLocker::mutex() const

Gibt den Mutex zurück, auf dem die Funktion „ QMutexLocker “ ausgeführt wird.

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

Sperrt einen entsperrten Mutex-Locker erneut.

Hinweis: Diese Funktion ist „noexcept“, wenn „ LockIsNoexcept “ „ true “ ist.

Siehe auch ` unlock()`.

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

Tauscht den Mutex und den Status dieses QMutexLocker mit other aus. Dieser Vorgang ist sehr schnell und schlägt niemals fehl.

Diese Funktion wurde in Qt 6.4 eingeführt.

Siehe auch ` QMutex::lock()`.

[noexcept] void QMutexLocker::unlock()

Entsperrt diesen Mutex-Locker. Mit „ relock() “ können Sie ihn erneut sperren. Beim Löschen muss er nicht gesperrt sein.

Siehe auch „ relock()“.

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

Mit „move“ wird other auf dieses QMutexLocker übertragen. Falls dieses QMutexLocker vor der Zuweisung einen gesperrten Mutex gehalten hat, wird der Mutex entsperrt. Der Mutex und der Zustand von other werden dann auf dieses QMutexLocker übertragen. Nach dem Move verwaltet other keinen Mutex mehr.

Diese Funktion wurde in Qt 6.4 eingeführt.

Siehe auch ` 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.