如何利用Qt使QObject方法线程安全

How to leverage Qt to make a QObject method thread-safe?

本文关键字：方法 线程 安全 QObject 何利用 Qt      更新时间：2023-10-16

假设我们在QObject派生类中编写了一个非常量方法：

class MyClass : public QObject {
  int x;
public:
  void method(int a) {
    x = a; // and possibly other things
  };
};

我们希望使该方法具有线程安全性：这意味着从任意线程和多个线程同时调用它不应该引入未定义的行为。

  1. Qt提供了哪些机制/API来帮助我们确保该方法的线程安全？

  2. 当方法也做"其他事情"时，可以使用Qt中的哪些机制/API？

  3. 是否有可能对"其他事物"进行分类，以告知要使用哪些特定于Qt的机制/API？

脱离主题的是C++标准本身提供的机制，以及确保线程安全的通用/非Qt特定方法。

适用的Qt API取决于线程安全方法的功能。让我们从最一般到最具体地介绍一下情况。

信号

信号体由moc工具生成，并且是线程安全的。

推论1:所有直接连接的槽/函子都必须是线程安全的：否则会破坏信号的契约。虽然信号槽系统允许代码解耦，但直接连接的特定情况会将信号的要求泄露给连接的代码！

推论2:直接连接比自动连接耦合得更紧密

在对象的线程中执行工作

最通用的方法是确保方法总是在对象的thread()中执行。这使得它相对于对象是线程安全的，但当然，方法中任何其他对象的使用也必须是线程安全完成的。

通常，线程不安全的方法只能从对象的thread():调用

void MyObject::method() {
  Q_ASSERT(thread() == QThread::currentThread());
  ...
}

无线程对象的特殊情况需要注意。当一个对象的线程结束时，该对象将变为无线程。然而，仅仅因为对象是无线程的，并不能使它的所有方法都是线程安全的。出于线程安全的目的，最好选择一个线程来"拥有"这些对象。这样的线程可能是主线程：

Q_ASSERT(QThread::currentThread() == (thread() ? thread() : qApp()->thread()));

我们的工作就是实现这一主张。方法如下：

  1. 利用线程安全信号。

    由于信号是线程安全的，我们可以将我们的方法作为信号，并将其实现托管在一个插槽中：

    class MyObject : public QObject {
  Q_OBJECT
  int x;
  void method_impl(int a) {
    x = a;
  }
  Q_SIGNAL void method_signal(int);
public:
  void method(int a) { method_signal(a); }
  MyObject(QObject * parent = nullptr) : QObject{parent} {
    connect(this, &MyObject::method, this, &MyObject::method_impl);
  }
};

    这种方法可以支持断言，但很冗长，并为每个参数执行额外的动态分配(至少从Qt 5.7开始(。

  2. 将函子中的调用分派到对象的线程。

    有很多方法可以做到这一点；让我们介绍一个动态分配次数最少的：在大多数情况下，只分配一个。

    我们可以将方法的调用封装在函子中，并确保它在线程中安全执行：

    void method1(int val) {
   if (!isSafe(this))
      return postCall(this, [=]{ method1(val); });
   qDebug() << __FUNCTION__;
   num = val;
}

    如果当前线程是对象的线程，则不会产生开销，也不会复制数据。否则，调用将延迟到对象线程中的事件循环，如果对象是无线程的，则延迟到主事件循环。

    bool isSafe(QObject * obj) {
   Q_ASSERT(obj->thread() || qApp && qApp->thread() == QThread::currentThread());
   auto thread = obj->thread() ? obj->thread() : qApp->thread();
   return thread == QThread::currentThread();
}
template <typename Fun> void postCall(QObject * obj, Fun && fun) {
   qDebug() << __FUNCTION__;
   struct Event : public QEvent {
      using F = typename std::decay<Fun>::type;
      F fun;
      Event(F && fun) : QEvent(QEvent::None), fun(std::move(fun)) {}
      Event(const F & fun) : QEvent(QEvent::None), fun(fun) {}
      ~Event() { fun(); }
   };
   QCoreApplication::postEvent(
            obj->thread() ? obj : qApp, new Event(std::forward<Fun>(fun)));
}

  3. 将调用分派到对象的线程。

    这是上面的变体，但没有使用函子。postCall函数可以显式包装参数：

    void method2(const QString &val) {
   if (!isSafe(this))
      return postCall(this, &Class::method2, val);
   qDebug() << __FUNCTION__;
   str = val;
}

    然后：

    template <typename Class, typename... Args>
struct CallEvent : public QEvent {
   // See https://stackoverflow.com/a/7858971/1329652
   // See also https://stackoverflow.com/a/15338881/1329652
   template <int ...> struct seq {};
   template <int N, int... S> struct gens { using type = typename gens<N-1, N-1, S...>::type; };
   template <int ...S>        struct gens<0, S...> { using type = seq<S...>; };
   template <int ...S>        void callFunc(seq<S...>) { (obj->*method)(std::get<S>(args)...); }
   Class * obj;
   void (Class::*method)(Args...);
   std::tuple<typename std::decay<Args>::type...> args;
   CallEvent(Class * obj, void (Class::*method)(Args...), Args&&... args) :
      QEvent(QEvent::None), obj(obj), method(method), args(std::move<Args>(args)...) {}
   ~CallEvent() { callFunc(typename gens<sizeof...(Args)>::type()); }
};
template <typename Class, typename... Args> void postCall(Class * obj, void (Class::*method)(Args...), Args&& ...args) {
   qDebug() << __FUNCTION__;
   QCoreApplication::postEvent(
            obj->thread() ? static_cast<QObject*>(obj) : qApp, new CallEvent<Class, Args...>{obj, method, std::forward<Args>(args)...});
}

保护对象的数据

如果该方法对一组成员进行操作，则可以通过使用互斥来序列化对这些成员的访问。利用QMutexLocker来表达您的意图，并通过构造来避免未发布的互斥错误。

class MyClass : public QObject {
  Q_OBJECT
  QMutex m_mutex;
  int m_a;
  int m_b;
public:
  void method(int a, int b) {
    QMutexLocker lock{&m_mutex};
    m_a = a;
    m_b = b;
  };
};

在使用特定于对象的互斥和调用对象线程中的方法体之间的选择取决于应用程序的需要。如果方法中访问的所有成员都是私有的，那么使用互斥是有意义的，因为我们处于控制之中，并且可以通过设计确保所有访问都受到保护。使用特定于对象的互斥体还可以将方法与对象事件循环上的争用解耦，因此可能具有性能优势。另一方面，如果方法必须访问它不拥有的对象上的线程不安全的方法，那么互斥锁就不够了，方法的主体应该在对象的线程中执行。

读取简单成员变量

如果const方法读取一段可以封装在QAtomicInteger或QAtomicPointer中的数据，我们可以使用原子字段：

class MyClass : public QObject {
  QAtomicInteger<int> x;
public:
  /// Thread-Safe
  int method() const {
    return x.load();
  };
};

修改简单成员变量

如果该方法修改了可以封装在QAtomicInteger或QAtomicPointer、和中的单个数据，则可以使用原子原语来完成操作，我们可以使用原子字段：

class MyClass : public QObject {
  QAtomicInteger<int> x;
public:
  /// Thread-Safe
  void method(int a) {
    x.fetchAndStoreOrdered(a);
  };
};

这种方法通常不会扩展到修改多个成员：某些成员已更改而另一些成员未更改的中间状态对其他线程可见。通常这会破坏其他代码所依赖的不变量。

相关文章：