QMutex ¶

概要 ¶

详细描述 ¶

The purpose of a QMutex is to protect an object, data structure or section of code so that only one thread can access it at a time (this is similar to the Java synchronized 关键词)。通常使用互斥最好采用 QMutexLocker 因为这样使之能轻松确保锁定和解锁被一致履行。

例如，假定有方法每 2 行向用户打印消息：

number = 6
def method1():
    number *= 5
    number /= 4
def method2():
    number *= 3
    number /= 2
											

若连续调用这 2 方法，会发生以下：

# method1()
number *= 5        # number is now 30
number /= 4        # number is now 7
# method2()
number *= 3        # number is now 21
number /= 2        # number is now 10
											

若从 2 线程同时调用这 2 方法，就会产生以下序列：

# Thread 1 calls method1()
number *= 5        # number is now 30
# Thread 2 calls method2().
#
# Most likely Thread 1 has been put to sleep by the operating
# system to allow Thread 2 to run.
number *= 3        # number is now 90
number /= 2        # number is now 45
# Thread 1 finishes executing.
number /= 4        # number is now 11, instead of 10
											

若添加互斥，应该获得希望结果：

mutex = QMutex()
number = 6
def method1():
    mutex.lock()
    number *= 5
    number /= 4
    mutex.unlock()
def method2():
    mutex.lock()
    number *= 3
    number /= 2
    mutex.unlock()
											

那么仅一线程可以修改 number 在任何给定时间且结果是正确的。当然，这是平凡范例，但适用于事情需要按特定序列发生的任何其它情况。

当调用 lock() in a thread, other threads that try to call lock() in the same place will block until the thread that got the lock calls unlock() . A non-blocking alternative to lock() is tryLock() .

QMutex is optimized to be fast in the non-contended case. A non-recursive QMutex will not allocate memory if there is no contention on that mutex. It is constructed and destroyed with almost no overhead, which means it is fine to have many mutexes as part of other classes.

另请参阅

QRecursiveMutex QMutexLocker QReadWriteLock QSemaphore QWaitCondition

class QMutex ¶

QMutex(mode)

param mode

RecursionMode

Constructs a new mutex. The mutex is created in an unlocked state.

Constructs a new mutex. The mutex is created in an unlocked state.

若 mode is Recursive , a thread can lock the same mutex multiple times and the mutex won’t be unlocked until a corresponding number of unlock() calls have been made. Otherwise a thread may only lock a mutex once. The default is NonRecursive .

Recursive mutexes are slower and take more memory than non-recursive ones.

另请参阅

lock() unlock()

PySide2.QtCore.QMutex. RecursionMode ¶

常量	描述
QMutex.Recursive	In this mode, a thread can lock the same mutex multiple times and the mutex won’t be unlocked until a corresponding number of unlock() calls have been made. You should use QRecursiveMutex for this use-case.
QMutex.NonRecursive	In this mode, a thread may only lock a mutex once.

另请参阅

QMutex() QRecursiveMutex

PySide2.QtCore.QMutex. tryLock ( [ timeout=0 ] ) ¶

参数

timeout – int

返回类型

bool

Attempts to lock the mutex. This function returns true 若获得锁；否则它返回 false . If another thread has locked the mutex, this function will wait for at most timeout milliseconds for the mutex to become available.

Note: Passing a negative number as the timeout is equivalent to calling lock() , i.e. this function will wait forever until mutex can be locked if timeout is negative.

If the lock was obtained, the mutex must be unlocked with unlock() before another thread can successfully lock it.

Calling this function multiple times on the same mutex from the same thread is allowed if this mutex is a recursive mutex . If this mutex is a non-recursive mutex , this function will always return false when attempting to lock the mutex recursively.

另请参阅

lock() unlock()