[QtCore module]

该QMutexLocker类是简化了锁定和解锁互斥一个方便的类。More…

Methods

  • __init__ (self, QMutex m)
  • QMutex mutex (self)
  • relock (self)
  • unlock (self)

Special Methods

  • object __enter__ (self)
  • __exit__ (self, object type, object value, object traceback)

Detailed Description

该QMutexLocker类是简化了锁定和解锁互斥一个方便的类。

锁定和解锁QMutex在复杂的函数和语句或异常处理代码很容易出错，难以调试。 QMutexLocker可以在这样的情况下使用，以确保始终良好定义的互斥的状态。

QMutexLocker应该在一个函数中创建一个地方QMutex需要被锁定。创建QMutexLocker当互斥被锁定。你可以解锁和重新锁定互斥与unlock()和relock()。如果被锁定，当QMutexLocker被销毁互斥将被解锁。

例如，这种复杂的功能可以锁定一个QMutex在进入功能和解锁互斥量在所有的出口点：

  1.  int complexFunction(int flag)
  2.  {
  3.      mutex.lock();
  5.      int retVal = 0;
  7.      switch (flag) {
  8.      case 0:
  9.      case 1:
  10.          retVal = moreComplexFunction(flag);
  11.          break;
  12.      case 2:
  13.          {
  14.              int status = anotherFunction();
  15.              if (status < 0) {
  16.                  mutex.unlock();
  17.                  return -2;
  18.              }
  19.              retVal = status + flag;
  20.          }
  21.          break;
  22.      default:
  23.          if (flag > 10) {
  24.              mutex.unlock();
  25.              return -1;
  26.          }
  27.          break;
  28.      }
  30.      mutex.unlock();
  31.      return retVal;
  32.  }

这个例子功能将变得更加复杂，因为它是发展，从而增加将发生错误的可能性。

使用QMutexLocker大大简化了代码，并使其更具可读性：

  1.  int complexFunction(int flag)
  2.  {
  3.      QMutexLocker locker(&mutex);
  5.      int retVal = 0;
  7.      switch (flag) {
  8.      case 0:
  9.      case 1:
  10.          return moreComplexFunction(flag);
  11.      case 2:
  12.          {
  13.              int status = anotherFunction();
  14.              if (status < 0)
  15.                  return -2;
  16.              retVal = status + flag;
  17.          }
  18.          break;
  19.      default:
  20.          if (flag > 10)
  21.              return -1;
  22.          break;
  23.      }
  25.      return retVal;
  26.  }

现在，互斥总是会在QMutexLocker对象被销毁（因为当函数返回解锁locker是一个自动变量） 。

同样的原则也适用于抛出和捕获异常的代码。未陷入已锁定互斥锁功能异常有没有办法解锁互斥前异常堆栈向上传递到调用函数的。

QMutexLocker还提供了一个mutex()成员函数，返回在其上QMutexLocker运行互斥。这对于需要访问互斥的代码很有用，比如QWaitCondition.wait（ ） 。例如：

  1.  class SignalWaiter
  2.  {
  3.  private:
  4.      QMutexLocker locker;
  6.  public:
  7.      SignalWaiter([QMutex](docs_qmutex.html) *mutex)
  8.          : locker(mutex)
  9.      {
  10.      }
  12.      void waitForSignal()
  13.      {
  14.          ...
  15.          while (!signalled)
  16.              waitCondition.wait(locker.mutex());
  17.          ...
  18.      }
  19.  };

Method Documentation

  1. QMutexLocker.__init__ (self, QMutex m)

构造一个QMutexLocker和锁mutex。互斥锁将被解锁时，QMutexLocker被破坏。如果mutex是零，QMutexLocker什么都不做。

See also QMutex.lock（ ） 。

  1. QMutex QMutexLocker.mutex (self)

[

返回一个指针，指向被锁在构造函数中的互斥体。

  1. QMutexLocker.relock (self)

重新锁定未锁定互斥锁储物柜。

](docs_qmutex.html)

See also unlock（ ） 。

  1. QMutexLocker.unlock (self)

这个解锁互斥锁固剂。您可以使用relock()再次锁定。它并不需要被破坏时被锁定。

See also relock（ ） 。

  1. object QMutexLocker.__enter__ (self)
  1. QMutexLocker.__exit__ (self, object type, object value, object traceback)