槽函数在什么线程下运行由什么决定，由链接信号和槽时所在的线程决定吗？

原创 已于 2025-02-08 14:39:44 修改 · 330 阅读 · 3 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#开发语言 #qt

于 2024-07-19 15:04:30 首次发布

1.概要

2.内容

在Qt中，当信号和槽的所属对象在不同的线程下运行时，槽函数执行的线程并不是简单地由链接信号和槽时所在的线程决定的。实际上，它取决于几个关键因素，主要是信号和槽的连接方式以及接收槽函数的对象的线程亲和性。以下是对这一问题的详细解答：

  1. 连接方式：Qt中信号和槽的连接方式有三种：Qt::DirectConnection，Qt::QueuedConnection，和Qt::BlockingQueuedConnection。这些连接方式直接影响了槽函数执行的线程。

    • Qt::DirectConnection：如果信号和槽使用直接连接，那么无论信号和槽的对象是否在同一个线程，槽函数都会在信号发出的线程中立即被调用。也就是说，如果信号在子线程中发出，槽函数也会在子线程中执行。

    • Qt::QueuedConnection：当使用队列连接时，槽函数会在接收者对象所在线程的事件循环中被调用。这意味着，即使信号在子线程中发送，槽函数也会在接收者对象所在的线程（可能是主线程或其他线程）中执行。

    • Qt::BlockingQueuedConnection：这种连接方式与Qt::QueuedConnection类似，不同之处在于，发送信号的线程会阻塞，直到槽函数执行完毕。但槽函数的执行仍然是在接收者对象的线程中。

  2. 接收者的线程亲和性：槽函数执行的线程还与接收槽函数的对象的线程亲和性有关。在Qt中，每个QObject都可以被移动到特定的线程中（通过QObject::moveToThread）。一旦一个对象被移动到了新的线程，它的槽函数就会在那个线程的事件循环中被调用，前提是使用了队列连接或阻塞队列连接。

综上所述，槽函数在什么线程下运行并不是简单地由链接信号和槽时所在的线程决定的，而是由信号和槽的连接方式以及接收槽函数的对象的线程亲和性共同决定的。在实际编程中，开发者需要根据具体的应用场景和需求来选择合适的连接方式，并确保线程安全。

3.关联链接 

4.关联知识

1.qt的线程亲和性

在Qt中，线程亲和性（Thread Affinity）是指一个QObject对象与一个特定线程相关联的特性。这种关联决定了对象在哪个线程中执行其槽函数和定时器事件等。以下是关于Qt线程亲和性的详细解释：

1. 线程亲和性的概念

  • 定义：一个QObject对象具有线程亲和性，意味着它生存在某个特定的线程中。当一个QObject对象接收到一个queued signal或一个posted event时，相应的槽函数或事件处理器会在该对象所生存的线程中执行。
  • 默认行为：默认情况下，QObject对象生存在创建它的那个线程中。可以通过thread()函数查询对象的线程亲和性。

2. 线程亲和性的管理

  • moveToThread()函数：使用QObject::moveToThread(QThread *thread)函数可以改变一个对象的线程亲和性。移动后的对象槽函数将在新的线程中执行。这意味着如果对象在新线程中被信号触发，其槽函数将在新线程的上下文中运行。
  • 父子关系：所有的QObject对象都与它们的父对象生存在同一个线程中。当一个QObject对象被移动到其他线程时，如果它们有子对象，这些子对象也会自动被移动。但是，如果子对象是通过成员变量（而非setParent()）关联的，则不会自动跟随父对象移动。因此，需要显式地调用moveToThread()函数来移动这些子对象。
  • 限制条件：
    • 如果一个QObject对象已经指定了父对象，则调用moveToThread()函数将会失败。
    • 如果一个QObject对象是在QThread::run()函数中被创建的，那么它们不能成为QThread对象的孩子，因为QThread对象并不生存在调用QThread::run()的那个线程中。

3. 线程亲和性与对象内部的对象

  • 成员对象：如果QObject对象的成员对象是普通的非QObject派生类对象，它们没有线程亲和性的概念。这些成员对象的数据和行为完全由包含它们的QObject对象的线程上下文决定。
  • QObject派生类对象：如果QObject对象的成员对象是QObject派生类对象，并且没有显式设置线程亲和性，它们将遵循其父对象的线程亲和性规则（除非被显式移动到其他线程）。
  • 线程安全问题：当对象在新线程中访问共享数据（包括成员对象和子对象）时，需要考虑线程安全问题。Qt提供了如QMutex、QReadWriteLock等同步原语来帮助管理线程间的数据访问。

4. 线程亲和性的应用示例

以下是一个简单的示例，演示如何使用moveToThread()函数将QObject对象移动到另一个线程：

#include <QCoreApplication>
#include <QThread>
#include <QDebug>

class Worker : public QObject {
    Q_OBJECT

public slots:
    void doWork() {
        qDebug() << "Worker::doWork() in thread" << this->thread();
    }
};

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    QThread *thread = new QThread;
    Worker *worker = new Worker;

    worker->moveToThread(thread);

    QObject::connect(thread, &QThread::started, worker, &Worker::doWork);

    thread->start();

    return app.exec();
}

在这个示例中，Worker对象被移动到新的线程中，并在该线程中执行其槽函数doWork()。

5. 注意事项

  • 避免跨线程访问共享数据：在设计多线程应用程序时，应尽量避免在多个线程之间共享QObject对象或其成员对象，因为这会增加复杂性和潜在的线程问题。如果需要在多个线程之间共享数据或功能，考虑使用信号和槽机制、共享数据结构（如QSharedPointer）或线程安全的容器。
  • 线程同步：当需要在多个线程之间共享数据时，必须使用适当的同步机制（如互斥锁、读写锁等）来确保线程安全。
  • 事件循环：一个线程需要运行事件循环才能接收和处理queued signal和posted event。如果线程没有事件循环，则无法接收到这些信号和事件。

6. 线程亲和性与CPU亲和性

  • CPU亲和性：与线程亲和性不同，CPU亲和性是指将线程或进程绑定到特定的CPU核心上，以减少线程或进程在CPU核心之间的迁移，从而提高性能。在Qt中，可以使用QThread类的setAffinity()函数来设置线程的CPU亲和性。

总结来看，Qt的线程亲和性是一个重要的概念，它决定了QObject对象在哪个线程中执行其槽函数和定时器事件等。通过合理管理线程亲和性，可以开发出高效、稳定的多线程应用程序。

2.槽函数在什么线程下运行由谁决定 

在Qt中，槽函数在哪个线程下运行主要由以下几个方面决定：

  1. 信号与槽的连接类型：

    • Qt::DirectConnection：槽函数在信号发出者所在的线程中执行。这种连接类型是同步的，槽函数会立即被调用。如果信号和槽在同一个线程中，使用这种方式是合适的。如果信号和槽在不同的线程中，使用这种方式可能会导致不可预测的行为，因为它会直接在信号线程中调用槽函数，可能违反线程安全原则。

    • Qt::QueuedConnection：槽函数在信号接收者所在的线程中执行。信号发出者将信号和参数打包为事件，并将其添加到接收者线程的事件队列中。接收者线程的事件循环在适当的时候处理事件队列，从而执行槽函数。这种连接类型是异步的，槽函数不会立即被调用。如果信号和槽在不同的线程中，使用这种方式是常用的。

    • Qt::AutoConnection：这是默认的连接类型。如果信号和槽在同一个线程中，它等同于Qt::DirectConnection；如果信号和槽在不同的线程中，它等同于Qt::QueuedConnection。

    • Qt::BlockingQueuedConnection：与Qt::QueuedConnection类似，但发送信号的线程在槽函数执行完毕之前会一直处于阻塞状态。这种方式可能导致性能问题或死锁，如果槽函数执行时间过长或涉及到等待其他资源。

  2. 接收者对象的线程归属：

    • 槽函数所属的对象（即接收者对象）所在的线程也会影响槽函数的执行线程。如果接收者对象所在的线程与信号发出者所在的线程不同，并且连接类型为Qt::QueuedConnection或Qt::AutoConnection（在跨线程情况下），则槽函数会在接收者对象所在的线程中执行。

  3. 线程的事件循环：

    • 对于Qt::QueuedConnection类型的连接，接收者线程的事件循环是必须的。如果接收者线程没有事件循环，即使信号被发出，槽函数也不会被调用。因此，在使用Qt::QueuedConnection时，需要确保接收者线程已经启动了事件循环。

  4. 手动控制线程归属：

    • 在Qt中，可以通过QObject::moveToThread函数将对象移动到另一个线程中。这样，对象的槽函数就会在该线程中执行。这种方法允许开发者更灵活地控制槽函数的执行线程。

总结来看，槽函数在哪个线程下运行主要由信号和槽的连接类型、接收者对象的线程归属、线程的事件循环以及手动控制线程归属等因素决定。在实际开发中，需要根据具体的需求和场景来选择合适的连接类型和线程管理方式。

3.通过成员变量（而非setParent()）关联 

在Qt中，当通过成员变量（而非setParent()）关联QObject对象时，这些成员对象不会自动继承其父对象的线程亲和性。具体来说，如果一个QObject对象A通过成员变量持有一个QObject对象B（而非调用setParent(A)将B设置为A的子对象），那么对象B的线程亲和性将由其被创建时的线程决定，而不是由对象A的线程决定。

以下是对这一情况的详细解释：

线程亲和性概述

在Qt中，QObject对象具有线程亲和性，即它们与创建它们的线程相关联。这种关联决定了对象在哪个线程中执行其槽函数、事件处理器等。默认情况下，一个QObject对象生存在创建它的那个线程中。

成员变量关联与线程亲和性

  • 通过成员变量关联：当一个QObject对象（如对象A）通过一个成员变量持有另一个QObject对象（如对象B）时，这两个对象之间的关联是成员变量级别的，而不是父子对象级别的。因此，对象B的线程亲和性不会受到对象A的影响。

  • 通过setParent()关联：如果对象B通过setParent(A)被设置为对象A的子对象，那么对象B将继承对象A的线程亲和性。即，无论对象B在哪里被创建，它都会与对象A在同一个线程中执行。

线程亲和性的影响

  • 槽函数执行线程：由于通过成员变量关联的对象不会继承父对象的线程亲和性，因此，如果对象A和对象B在不同的线程中，并且对象B接收到一个信号，其槽函数将在对象B被创建时所在的线程中执行，而不是在对象A所在的线程中执行。

  • 线程安全：当对象A和对象B在不同的线程中，并且它们通过成员变量相互关联时，需要特别注意线程安全问题。因为这两个对象可能在不同的线程中访问共享数据，如果没有适当的同步机制（如互斥锁），可能会导致数据竞争或不一致。

示例说明

假设我们有两个QObject对象：ObjectA和ObjectB。ObjectA通过成员变量持有一个ObjectB的指针。

class ObjectA : public QObject {
    Q_OBJECT

public:
    ObjectA(QObject *parent = nullptr) : QObject(parent) {
        objectB = new ObjectB(this); // 注意：这里虽然传入了this作为parent，但并未调用setParent()
    }

    ~ObjectA() {
        delete objectB;
    }

    void someFunction() {
        // 假设这里发出一个信号给objectB
    }

private:
    ObjectB *objectB;
};

class ObjectB : public QObject {
    Q_OBJECT

public slots:
    void someSlot() {
        // 槽函数实现
    }
};

在上面的示例中，虽然ObjectA的构造函数中传入了this作为ObjectB的父对象参数，但由于没有调用setParent(this)，ObjectB并不会成为ObjectA的子对象。因此，ObjectB的线程亲和性将由其被创建时的线程决定，而不是由ObjectA的线程决定。

结论

通过成员变量（而非setParent()）关联QObject对象时，这些成员对象不会自动继承其父对象的线程亲和性。因此，在多线程环境中使用这种关联方式时需要特别注意线程安全问题，并确保对象之间的通信是线程安全的。

4.通过setParent()关联的对象线程移动举例 

在Qt中，setParent()函数用于设置一个QObject对象的父对象，这会影响对象的生命周期和线程亲和性。特别是，当你将一个QObject对象设置为另一个对象的子对象时，子对象会继承父对象的线程亲和性。因此，如果你将一个对象移动到另一个线程中（通过moveToThread()），它的子对象也会随之移动到该线程。

以下是一个简单的示例，展示了如何使用setParent()和moveToThread()来关联对象并改变它们的线程亲和性。

示例代码

#include <QCoreApplication>
#include <QObject>
#include <QThread>
#include <QDebug>

class ChildObject : public QObject {
    Q_OBJECT

public slots:
    void doSomething() {
        qDebug() << "ChildObject::doSomething() running in thread:" << QThread::currentThread();
    }
};

class ParentObject : public QObject {
    Q_OBJECT

public:
    ParentObject(QObject *parent = nullptr) : QObject(parent) {
        //childObject = new ChildObject(this); // 设置子对象
        childObject = new ChildObject(); // 设置子对象
        childObject->setParent(this); // 设置父对象
    }

signals:
    void triggerChild();

private:
    ChildObject *childObject;
};

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    QThread workerThread;
    ParentObject parentObject;

    // 将ParentObject移动到workerThread
    parentObject.moveToThread(&workerThread);

    // 连接信号和槽
    QObject::connect(&parentObject, &ParentObject::triggerChild, parentObject.childObject, &ChildObject::doSomething);

    // 启动线程
    workerThread.start();

    // 触发信号
    QMetaObject::invokeMethod(&parentObject, "triggerChild", Qt::QueuedConnection);

    // 运行应用程序事件循环
    int result = app.exec();

    // 清理
    workerThread.quit();
    workerThread.wait();

    return result;
}

#include "main.moc"

解释

  1. 类定义：
    • ChildObject：一个QObject子类，包含一个槽函数doSomething()，用于输出当前线程的信息。
    • ParentObject：另一个QObject子类，包含一个ChildObject类型的子对象。
  2. 设置父子关系：
    • 在ParentObject的构造函数中，通过new ChildObject(this)将ChildObject设置为ParentObject的子对象。这意味着ChildObject的生命周期由ParentObject管理，并且它会继承ParentObject的线程亲和性。
  3. 移动线程：
    • 使用parentObject.moveToThread(&workerThread)将ParentObject（及其子对象ChildObject）移动到workerThread。这样，ParentObject和ChildObject的槽函数都会在workerThread中执行。
  4. 信号与槽连接：
    • 使用QObject::connect将ParentObject的triggerChild信号连接到ChildObject的doSomething槽。由于连接类型默认为Qt::AutoConnection，并且信号发出者和接收者在不同的线程中，因此连接类型会自动选择为Qt::QueuedConnection。
  5. 触发信号：
    • 使用QMetaObject::invokeMethod以异步方式触发ParentObject的triggerChild信号。这确保了信号在事件循环的适当时刻被处理。
  6. 应用程序事件循环：
    • 调用app.exec()启动应用程序的事件循环，使信号和槽能够正常工作。
  7. 清理：
    • 在程序退出前，调用workerThread.quit()和workerThread.wait()来停止和等待线程结束，确保程序能够正常退出。

运行结果

当你运行这个程序时，你会看到输出类似于：

ChildObject::doSomething() running in thread: QThread(0x12345678)

这里的QThread(0x12345678)表示ChildObject::doSomething()在workerThread中执行。这证明了通过setParent()关联的对象在父对象移动到另一个线程时，其线程亲和性也会随之改变。

5.setParent() 

setParent() 是 Qt 中 QObject 类的一个成员函数，用于设置一个对象的父对象。这一操作不仅影响对象的生命周期管理，还涉及对象的线程亲和性。下面详细介绍 setParent() 的作用及其使用场景。

作用

  1. 生命周期管理：
    • 当一个 QObject 对象被设置为另一个对象的子对象时，子对象的生命周期将由父对象管理。这意味着当父对象被销毁时，子对象也会自动销毁。这简化了内存管理，因为开发者不需要手动销毁每个子对象。
  2. 线程亲和性：
    • 在 Qt 中，每个 QObject 对象都有一个与之关联的线程，称为线程亲和性（thread affinity）。默认情况下，对象在创建它的线程中具有亲和性。
    • 当一个对象通过 setParent() 被设置为另一个对象的子对象时，子对象会继承父对象的线程亲和性。因此，如果父对象被移动到一个新的线程中（通过 moveToThread()），子对象也会随之移动到该线程。

使用场景

  • 构建对象层次结构：
    • 在 Qt 应用程序中，常常需要构建复杂的对象层次结构。通过 setParent()，可以方便地将一个对象嵌套到另一个对象中，形成树状结构。
  • 管理内存和资源：
    • 使用 setParent() 可以避免手动管理对象的内存释放。当父对象被销毁时，所有子对象会自动销毁，减少了内存泄漏的风险。
  • 多线程编程：
    • 在多线程环境中，通过 setParent() 将对象关联到一个特定线程的对象上，可以确保这些对象在正确的线程中执行其槽函数和事件处理。

示例

以下是一个简单的示例，展示了如何使用 setParent() 来关联对象：

#include <QCoreApplication>
#include <QObject>
#include <QThread>
#include <QDebug>

class ChildObject : public QObject {
    Q_OBJECT

public slots:
    void doSomething() {
        qDebug() << "ChildObject::doSomething() running in thread:" << QThread::currentThread();
    }
};

class ParentObject : public QObject {
    Q_OBJECT

public:
    ParentObject(QObject *parent = nullptr) : QObject(parent) {
        childObject = new ChildObject();
        childObject->setParent(this); // 设置父对象
    }

signals:
    void triggerChild();

private:
    ChildObject *childObject;
};

int main(int argc, char *argv[]) {
    QCoreApplication app(argc, argv);

    QThread workerThread;
    ParentObject parentObject;

    // 将ParentObject移动到workerThread
    parentObject.moveToThread(&workerThread);

    // 连接信号和槽
    QObject::connect(&parentObject, &ParentObject::triggerChild, parentObject.childObject, &ChildObject::doSomething);

    // 启动线程
    workerThread.start();

    // 触发信号
    QMetaObject::invokeMethod(&parentObject, "triggerChild", Qt::QueuedConnection);

    // 运行应用程序事件循环
    int result = app.exec();

    // 清理
    workerThread.quit();
    workerThread.wait();

    return result;
}

#include "main.moc"

代码解释

  1. 对象创建和父子关系：
    • ChildObject 实例化后，通过 childObject->setParent(this) 将其父对象设置为 ParentObject。
  2. 线程移动：
    • parentObject.moveToThread(&workerThread) 将 ParentObject（及其子对象 ChildObject）移动到 workerThread。
  3. 信号与槽连接：
    • 连接 ParentObject 的信号 triggerChild 到 ChildObject 的槽 doSomething。
  4. 信号触发：
    • 使用 QMetaObject::invokeMethod 异步触发 triggerChild 信号。
  5. 事件循环和清理：
    • app.exec() 启动事件循环。
    • 程序结束前，停止并等待 workerThread 完成。

通过这种方式，ChildObject 的槽函数会在 workerThread 中执行，展示了 setParent() 在线程亲和性方面的作用。

 

万字长文，从0到1手写一个工业级C++信号槽，设计一个线程安全的C++回调系统
weixin_45715405的博客
11-05 46
本文探讨了多线程编程在现代软件开发中的必要性及其固有挑战，如线程安全、死锁和跨线程通信等。提出了一种基于C++标准库的轻量级解决方案，融合了信号槽机制和事件循环模型。信号槽实现松耦合的事件处理，而事件循环模型通过线程安全的事件队列管理跨线程调用。核心组件包括Object基类的线程归属管理和事件循环绑定，为开发者提供清晰的API设计和高内聚、低耦合的模块化架构，从而有效解决并发编程中的复杂性问题。
多线程中的信号与槽
随心小记
08-31 3587
如果程序中有多个线程，槽函数在哪个线程中执行？ 只要函数体中没有访问临界资源的代码，同一个函数可以被多个线程同时调用，且不会产生任何副作用研究槽函数的具体执行线程意义：当信号的发送与对应槽函数的执行在不同线程中时，可能产生临界资源的竞争问题无论事件循环是否开启，信号发送后会直接进入对象所依附线程的事件队列；然而，只有开启了事件循环，对应的槽函数才会在线程中被调用什么时候需要在线程中开启事件循环？
qt 线程问题 信号触发 使其 槽函数在子线程中运行
woquNOKIA的专栏
12-24 3424
系统：win10 qtcreater：5.12.10 条件：使用this->moveToThread( &m_thread );//m_thread 为QThread 的对象 //this 为一个继承Qobject的类 此例中为ADThread 目标 触发信号 使其槽函数在m_thread (子线程)中运行。 现象：1：类中 使用ADThread 的信号触发的化 只能在其成员方法中触发 可以 2：类外 使用ADThread 继承基类的信号触发 ...
Qt 设置CPU亲缘性，把进程和线程绑定到CPU核心上(Linux)
DreamLife
11-18 7332
哎呀，说多了都是泪，一直以为Arm Linux 天下无敌，谁知道性能还是没法和PC比，不过也是，毕竟功耗在那摆着呢。这不，最近遇到了一个问题，就是使用[QCustomPlot](https://www.qcustomplot.com/index.php/introduction)绘制曲线的时候，在一屏200个点的时候没有问题，但是当我绘制 `8K×5×2`个点的时候，就卡的要死要死的，虽然加入了线程，但是还是未解决，所以就想到了这个，设置CPU亲缘性，但是每个平台的设置方式还不一样，所以今天的这个是在`Li
主动设置进程CPU绑定（CPU亲和性）解决QT多线程在Linux上只使用单核的问题
piaopiaolanghua的专栏
05-07 2065
因此通过pthread_setaffinity_np在主线程中设置亲和性（了解到子线程会继承的），但是不起效果，有继续翻博客，发现还有进程亲和性的设置函数，想着是不是设置主线程不行，应该设置进程呢，于是用sched_setaffinity来设置（见本博客开头的插图中的代码）发现可以了。使用QT的多线程进行计算密集型任务，线程数不少于CPU的逻辑处理单元数，但是在Linux上查看系统监视器，总是只占用一个核（不超过100%），Window下是没有这个问题的。查看特定某个进程线程使用内存情况。
qt 线程、信号、槽、触发的槽函数在那个线程运行
xie__jin__cheng的博客
08-30 3501
qt 线程、信号、槽、触发的槽函数在那个线程运行
Qt 信号槽原理 - 槽函数调用时机
qq_62381297的博客
01-03 3300
通过阅读信号槽相关源码，了解信号槽机制，知道槽函数的调用时机
qt 跨线程传递信号，不进槽函数
03-11
当遇到Qt中跨线程传递信号但不触发槽函数的问题时，通常是因为接收者所在的线程没有正常运行的消息循环。消息循环对于处理事件和调度任务至关重要，在Qt框架下尤其如此。 如果子线程中的`CSignalSlot`对象所属线程...
我在将Qt界面中的按钮与线程中的槽链接后，为什么没有起作用
10-29
- 如果槽函数所在的线程是一个QThread子类，并且没有调用`exec()`启动事件循环，那么即使信号发出，槽函数也可能无法执行。因为队列连接依赖于目标线程的事件循环。 原因3：信号与槽的参数类型未注册 - 如果信号...
QT踩坑记录2-多线程信号与槽
Fxxk CPP
03-25 472
错误输出 无错误输出, 但是声明了信号的连接,但是无法使用 程序中就是无命令 介绍 QT 典型程序 #include <QObject> class MyClass:public QObject { Q_OBJECT signals: void signals_dosomething(int n); public slots: void slots_dosom...
在qt中多线程环境下，信号槽分别是在什么样的线程中执行？如何控制？
qq_46117468的博客
03-20 674
在多线程环境下，使用 Qt::QueuedConnection 连接方式可以确保信号的槽函数在接收者对象所在的线程中执行。使用信号和槽的线程安全机制：在多线程环境下，确保在对共享数据进行访问时采取适当的线程安全措施，比如使用互斥锁或者信号量来保护共享资源。2、如果信号和槽属于不同的对象，并且这些对象位于不同的线程中，那么槽函数的执行会在接收者对象所在的线程中进行。总之，在多线程环境下，要控制信号和槽的执行线程，需要根据具体情况选择合适的连接方式，并确保操作的线程安全性。
QT中信号和槽用在多线程中
h1007886499的博客
03-12 7237
注意：Qt的信号与槽机制可以将任何继承自QObject类的对象捆绑在一起，使不同对象之间能够相互通信。connect用于连接qt的信号和槽，在qt编程过程中不可或缺。它其实有第五个参数，只是一般使用默认值，在满足某些特殊需求的时候可能需要手动设置。这是用在多线程中的重点。两个线程：1.class MyThread:public QThread { Q_OBJECT ... signals:......
QT信号槽的在不同线程或者在同一线程下的连接方式
wb175208的专栏
04-24 7089
最近使用一个QTreeWidget加载数据库数据然后以tree的方式展现出来。 于是在读取数据库的时候新建一个线程的来读取数据库，读取数据完毕之后，再树形控件上显示出来。 新建线程的目的是为了防止读取大数据的时候出现界面阻塞的情况，提供用户体验。然后数据读取完毕之后，是不能在工作线程中把读取到的数据显示出来的， 必须传到主界面上显示出来。只是就会使用信号槽的方式把读取的数据传到主界面。 信...
Qt进程-QProcess使用总结
热门推荐
Gerald_Jones的博客
05-31 1万+
一、启动外部程序分为两种方式： 阻塞式 execute() QProcess *pCaller = new QProcess(); // 阻塞调用 当前窗口处理结束关闭之后 主窗口才能操作 pCaller->execute("/home/gsk/Qt/build-Demo-child1-Desktop_Qt_5_12_3_GCC_64bit-Debug/Demo-child1"); 非阻塞式 start() 和 startDetached() QProcess *pCaller =
Kubernetes与开发语言：重新定义.NET Core与Java的云原生未来
百锦再的博客
12-17 1811
本文探讨了Kubernetes对Java和.NET Core两大开发语言的差异化影响。Java凭借Spring Cloud等成熟生态与Kubernetes逐步融合，通过镜像优化、资源调优适应容器环境；而.NET Core则借助跨平台特性在K8s中获得重生机遇。在部署运行方面，Java需针对容器特点进行深度优化，.NET Core则展现轻量级优势；服务治理上，Java存在传统框架与K8s原生方案的双轨选择，.NET Core更易接入服务网格。配置管理方面，Java依赖外部配置中心，.NET Core更灵活集成
qt-lambda信号槽机制
世转神风的博客
12-16 1248
本文探讨了Qt C++中lambda槽函数的生命周期管理问题。实验表明，lambda槽函数作为独立对象存在，即使使用std::function存储也会在传递过程中生成新对象。文章详细分析了不同场景下的生命周期规则：无捕获lambda独立存在；有捕获lambda的生命周期取决于receiver对象；若捕获指针/引用需使用QPointer等智能管理。关键结论指出lambda生命周期主要与捕获变量和receiver相关，而非信号发送对象。最后强调使用lambda槽函数时应确保其一次性使用特性，避免内存泄漏风险。最
【QT window】multimedia+ffmpeg实现(PCM和MP4)录音功能
最新发布
ocy的博客
12-20 149
前面有两篇使用纯ffmpeg库实现了PCM和MP4录音功能，几乎展示了所有涉及的流程（ffmpeg是一个C库，比较原生）。QT也有封装好的多媒体模块，能让流程变简单很多，这也是本篇的目的。
【Qt 5.14.2 新手实战】QTC++入门筑基——按钮与标签联动：QPushButton + QLabel 实现图片切换器
2202_75382767的博客
12-17 174
在面试中，“信号槽机制怎么用”是个常被问到的问题。别担心，今天咱们做的这个图片切换器就能帮你轻松吃透它！通过点击按钮就能切换美美的风景图，不仅能深入理解Qt 5.14.2的核心通信机制，还可以直接把这个项目作为“信号槽实战案例”写进简历呢，而且新手1小时就能完成哦。
Qt菜单项切换主界面
海涛高软
12-17 167
gjxm为点击某菜单弹框，需要重写关闭事件，对外发信号。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值