Qt面试题合集(三)

Qt面试合集三

5.Qt多线程编程为什么不直接继承QThread而是用workerObject？

两种方式都可以用。但是他们的使用场景有一些差别。

一.直接继承自QThread类。

使用示例：

c++ 复制代码

class MyThread : public QThread
{
    Q_OBJECT
protected:
    void run() override {
        // 业务逻辑：运行在新线程
        for(int i=0; i<1000; i++) {
            qDebug() << "Thread ID:" << QThread::currentThreadId();
        }
    }
};

// 使用
MyThread thread;
thread.start(); // 启动线程，执行run()

1.1 使用该方式的一些缺点：

事件循环没了

QThread 默认 run() 就是 exec()，你一旦重写 run 却没调 exec()，线程里 信号槽队列机制直接废掉------QueuedConnection 的信号无人分发。
资源释放失控

继承方式里，子类通常把 QThread 当临时对象 new MyThread(this)，结果外部直接 delete thread 会崩（线程还在跑）。外部不删就内存泄漏。
继承 QThread 容易踩坑：比如误在 QThread 子类的槽函数中操作 UI / 共享数据，导致线程安全问题；

4.Qt 的 QThread 只是一个线程管理句柄，并不是"线程本体"。把业务代码塞进 QThread 子类，等于把"管理对象"和"工作逻辑"。
扩展性极差：

若想给线程加多个任务，需修改run()函数，违反 "开闭原则"；

若想停止线程，需手动处理run()的循环退出，而 Worker-Object 可通过信号槽优雅停止（比如quit()）；

大型项目中，Worker-Object 配合线程池（QThreadPool+QRunnable）是更主流的方案，而继承 QThread 无法直接适配线程池。

1.2 适用场景：

它仅适用于无事件循环、纯计算型的简单场景 （比如run()里只执行一段一次性的计算，无槽函数、无信号通信）。

二.使用QObject::moveToThread()函数。

核心是将业务逻辑封装到普通 QObject 子类（Worker），再把 Worker 对象移到 QThread 中：

Worker 的所有槽函数（业务逻辑）都会运行在目标线程，天然避免线程安全问题。
线程管理（QThread）和业务逻辑（Worker）解耦：Worker 可复用，QThread 可替换（比如换成线程池）。
支持 Qt 的信号槽机制灵活通信（主线程发信号触发 Worker 的槽函数，Worker 发信号回传结果），符合 Qt 的 "事件循环" 设计理念。

使用示例：

C++ 复制代码

// 1. 定义工作对象（纯业务逻辑，不涉及线程管理）
class Worker : public QObject
{
    Q_OBJECT
public slots:
    void doWork() {
        // 业务逻辑：运行在QThread的线程中
        for(int i=0; i<1000; i++) {
            qDebug() << "Worker Thread ID:" << QThread::currentThreadId();
        }
        emit workDone(); // 通知主线程完成
    }
signals:
    void workDone();
};

// 2. 使用方式
QThread* thread = new QThread;
Worker* worker = new Worker;
worker->moveToThread(thread); // 关键：将Worker移到新线程

// 信号槽关联（触发/结束）
connect(thread, &QThread::started, worker, &Worker::doWork);
connect(worker, &Worker::workDone, thread, &QThread::quit);
connect(thread, &QThread::finished, thread, &QThread::deleteLater);
connect(thread, &QThread::finished, worker, &Worker::deleteLater);

thread->start(); // 启动线程，触发Worker的doWork槽

2.1 使用moveToThread方式的优点：

1. 线程生命周期管理更清晰

c++ 复制代码

// Worker方式：线程和对象生命周期分离
QThread thread;
Worker *worker = new Worker;
worker->moveToThread(&thread);

// 线程结束后自动清理
connect(&thread, &QThread::finished, worker, &QObject::deleteLater);
thread.start();

// 继承方式：线程结束意味着对象也结束，容易混淆

2. 避免线程亲和性问题

复制代码

// Worker方式明确区分：
// - Worker对象的方法在目标线程执行
// - Worker对象的构造函数在创建线程执行（通常是主线程）
// - 信号槽自动跨线程连接

// 继承方式容易混淆：哪些方法在子线程？哪些在主线程？

3. 更灵活的对象管理

C++ 复制代码

// 可以创建多个Worker共享一个线程
QThread thread;
Worker1 worker1;
Worker2 worker2;
worker1.moveToThread(&thread);
worker2.moveToThread(&thread);  // 两个对象共享线程

// 也可以一个Worker在不同时间使用不同线程
worker.moveToThread(thread1);
// ... 之后可以切换
worker.moveToThread(thread2);

4. 更好的代码组织

C++ 复制代码

// Worker方式：业务逻辑与线程管理解耦
class DataProcessor : public QObject {
    // 纯粹的业务逻辑，不关心线程
    void processData(Data data);
};

// 线程管理代码单独处理
processor->moveToThread(&processingThread);

// 继承方式：业务逻辑和线程代码耦合
class MyThread : public QThread {
    void run() {
        // 这里既有线程控制又有业务逻辑
    }
};

2.2 实际应用建议：

C++ 复制代码

// 现代Qt多线程最佳实践组合：
// 1. Worker对象处理业务逻辑
// 2. moveToThread管理线程亲和性  
// 3. QThreadPool + QRunnable处理短任务
// 4. QtConcurrent处理数据并行

// 示例：完整的工作线程模式
class Controller : public QObject {
    QThread workerThread;
    
    Controller() {
        Worker *worker = new Worker;
        worker->moveToThread(&workerThread);
        
        connect(&workerThread, &QThread::finished,
                worker, &QObject::deleteLater);
        connect(this, &Controller::operate,
                worker, &Worker::doWork);
        connect(worker, &Worker::resultReady,
                this, &Controller::handleResults);
        
        workerThread.start();
    }
    
    ~Controller() {
        workerThread.quit();
        workerThread.wait();
    }
};

总结：

核心差异：继承 QThread 易混淆 "线程管理者" 和 "执行体"，导致线程安全问题；Worker-Object 解耦了线程管理和业务逻辑，符合 Qt 事件循环设计，更安全、易扩展。