[QtCore module]

该QMutex类提供线程之间的访问串行化。More…

Types

  • enum RecursionMode { NonRecursive, Recursive }

Methods

  • __init__ (self, RecursionMode mode = QMutex.NonRecursive)
  • lock (self)
  • bool tryLock (self)
  • bool tryLock (self, int timeout)
  • unlock (self)

Detailed Description

该QMutex类提供线程之间的访问串行化。

一个QMutex的目的是保护的对象，数据结构或代码部分，以便只有一个线程可以在同一时间访问它（这类似于Javasynchronized关键字）。它通常是最好使用一个互斥与QMutexLocker因为这可以很容易地确保锁定和解锁一贯执行。

例如，假设有一个打印一条消息，两行用户的方法：

  1.  int number = 6;
  3.  void method1()
  4.  {
  5.      number *= 5;
  6.      number /= 4;
  7.  }
  9.  void method2()
  10.  {
  11.      number *= 3;
  12.      number /= 2;
  13.  }

如果这两种方法称为连续，会发生以下情况：

  1.  // method1()
  2.  number *= 5;        // number is now 30
  3.  number /= 4;        // number is now 7
  5.  // method2()
  6.  number *= 3;        // number is now 21
  7.  number /= 2;        // number is now 10

如果这两种方法都从两个线程同时调用然后按下列顺序会导致：

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

如果我们添加了一个互斥体，我们应该得到我们想要的结果：

  1.  QMutex mutex;
  2.  int number = 6;
  4.  void method1()
  5.  {
  6.      mutex.lock();
  7.      number *= 5;
  8.      number /= 4;
  9.      mutex.unlock();
  10.  }
  12.  void method2()
  13.  {
  14.      mutex.lock();
  15.      number *= 3;
  16.      number /= 2;
  17.      mutex.unlock();
  18.  }

那么只有一个线程可以修改number在任何给定的时间，其结果是正确的。这是一个简单的例子，当然，但适用于任何其他情况下的事情需要发生在一个特定的顺序。

当你调用lock（ ）在一个线程，其它试图调用线程lock（ ）在同一个地方会阻塞，直到获得该锁调用的线程unlock（ ） 。非阻塞的替代品lock（）是tryLock（ ） 。

Type Documentation

  1. QMutex.RecursionMode
Constant Value Description
QMutex.Recursive 1 在这种模式下，一个线程可以锁定同一互斥多次和互斥不会被解锁，直到相应数量的unlock
（ ）的调用而制定的。
QMutex.NonRecursive 0 在这种模式下，一个线程可能只锁定一个互斥体一次。

See also QMutex（ ） 。

Method Documentation

  1. QMutex.__init__ (self, RecursionMode mode = QMutex.NonRecursive)

构造一个新的互斥体。互斥锁处于未锁定状态下创建。

If mode is QMutex.Recursive，一个线程可以锁定同一互斥多次和互斥不会被解锁，直到相应数量的unlock（ ）的调用而制定的。默认值是QMutex.NonRecursive。

See also lock（）和unlock（ ） 。

  1. QMutex.lock (self)

锁定互斥锁。如果另一个线程已锁定互斥锁，则该调用将被阻塞，直到该线程已经解锁了。

调用此函数从同一个线程相同的互斥体多次是允许的，如果这个互斥体是一个recursive mutex。如果这个互斥体是一个non-recursive mutex，此功能将dead-lock当互斥锁递归锁定。

See also unlock（ ） 。

  1. bool QMutex.tryLock (self)

试图锁定互斥。如果获得了锁，这个函数返回True。如果另一个线程已锁定互斥锁，则该函数立即返回False 。

如果获得了锁，互斥锁必须被解锁unlock（ ）之前，另一个线程可以成功地将其锁定。

调用此函数从同一个线程相同的互斥体多次是允许的，如果这个互斥体是一个recursive mutex。如果这个互斥体是一个non-recursive mutex，此功能将always尝试以递归方式锁定互斥时返回False 。

See also lock（）和unlock（ ） 。

  1. bool QMutex.tryLock (self, int timeout)

这是一个重载函数。

试图锁定互斥。如果获得了锁这个函数返回True，否则返回False 。如果另一个线程已锁定互斥锁，则此功能将等待最多timeout毫秒互斥体变得可用。

注意：传递一个负数作为timeout相当于调用lock（ ） ，即该函数将一直等待，直到互斥量能，如果被锁定timeout是负的。

如果获得了锁，互斥锁必须被解锁unlock（ ）之前，另一个线程可以成功地将其锁定。

调用此函数从同一个线程相同的互斥体多次是允许的，如果这个互斥体是一个recursive mutex。如果这个互斥体是一个non-recursive mutex，此功能将always尝试以递归方式锁定互斥时返回False 。

See also lock（）和unlock（ ） 。

  1. QMutex.unlock (self)

解锁互斥量。尝试在不同的线程在一个锁定它会导致一个错误解除锁定互斥锁。解锁未在不确定的行为锁定的互斥锁。

See also lock（ ） 。