关于Qt软件开发人员技术面试可能被问到的一些技术问题汇总（二）

牵牛老人

于 2025-03-03 19:17:35 发布

阅读量1k

点赞数 22

分类专栏： qt学习文章标签： qt 面试数据库

本文链接：https://blog.youkuaiyun.com/qianniulaoren/article/details/145995916

版权

qt学习专栏收录该内容

77 篇文章

订阅专栏

接着上一篇文章，继续说说Qt软件开发人员技术面试可能被问到的一些技术问题。

多线程部分

16. Qt 有哪些多线程的实现方式？

Qt 提供了多种多线程的实现方式，主要包括以下四种：

继承自QThread 类，重写 QThread 类的 run 方法：这是一种比较常见的实现方式。通过继承 QThread 类，并重写其 run 方法，在 run 方法中编写子线程要处理的具体业务流程。优点是实现简单，可以用信号槽通信；缺点是需要自己管理线程的创建和释放，频繁地创建和释放效率不高，所以适合常驻程序的线程使用。另外，因为 QThread 对象属于父线程，所以对象中的槽函数（如果有的话）其实会在父线程执行。示例代码如下：

#include <QThread> 
 
class MyThread : public QThread 
{ 
    Q_OBJECT 
protected: 
    void run() override { 
        // 子线程要处理的业务逻辑 
    } 
};

QThread 类与 MoveToThread：创建对象继承 QObject，将对象移动到子线程对象。通过这种方式，可以将一个 QObject 派生类的对象移动到一个新的线程中执行。缺点是只能通过信号槽的方式调用业务对象的接口，且不能给此对象指定父对象。示例代码如下：

#include <QObject> 
#include <QThread> 
 
class MyObject : public QObject 
{ 
    Q_OBJECT 
public slots: 
    void doWork() { 
        // 业务逻辑 
    } 
}; 
 
// 在主线程中使用 
QThread *thread = new QThread; 
MyObject *obj = new MyObject; 
obj->moveToThread(thread); 
connect(thread, &QThread::started, obj, &MyObject::doWork); 
thread->start();

QThreadPool 与 QRunnable：继承 QRunnable 实现 run 方法完成业务类创建，由 QThreadPool 启动业务类。QThreadPool 是一个线程池类，它可以管理多个线程，避免了频繁创建和释放线程的开销。优点是无需关注线程资源管理，不会频繁创建与释放线程，所以适用于需要频繁创建销毁线程的业务场景。示例代码如下：

#include <QRunnable> 
#include <QThreadPool> 
 
class MyRunnable : public QRunnable 
{ 
    void run() override { 
        // 业务逻辑 
    } 
}; 
 
// 在主线程中使用 
QThreadPool *pool = QThreadPool::globalInstance(); 
MyRunnable *runnable = new MyRunnable; 
pool->start(runnable);

QtConcurrent::run()：直接将任务丢进子线程执行。这是一种非常简单的多线程实现方式，通过 QtConcurrent::run() 函数可以将一个函数或 lambda 表达式放到一个子线程中执行。优点是调用简单，无需关注线程资源管理，不会频繁创建与释放线程。示例代码如下：

#include <QtConcurrent/QtConcurrent> 
 
void myFunction() { 
    // 业务逻辑 
} 
 
// 在主线程中使用 
QFuture<void> future = QtConcurrent::run(myFunction);

17. 如何处理多线程中的线程安全问题？

在多线程中处理线程安全问题通常可以采用以下几种方法：

互斥锁（QMutex）：互斥锁是一种最常用的同步机制，它可以保证同一时间只有一个线程可以访问共享资源。例如：

#include <QMutex> 
 
QMutex mutex; 
int sharedData = 0; 
 
void threadFunction() { 
    mutex.lock();  
    // 访问共享资源 
    sharedData++; 
    mutex.unlock();  
}

读写锁（QReadWriteLock）：读写锁适用于读多写少的场景，它允许多个线程同时进行读操作，但在写操作时会独占资源。例如：

#include <QReadWriteLock> 
 
QReadWriteLock rwLock; 
int sharedData = 0; 
 
void readFunction() { 
    rwLock.lockForRead();  
    // 读操作 
    int value = sharedData; 
    rwLock.unlock();  
} 
 
void writeFunction() { 
    rwLock.lockForWrite();  
    // 写操作 
    sharedData++; 
    rwLock.unlock();  
}

18. 在多线程环境下，如何确保 Qt 界面的线程安全？

在多线程环境下，Qt 要求所有与界面相关的操作都必须在主线程（也称为 GUI 线程）中执行，否则可能会导致界面崩溃或出现未定义行为。以下是几种确保 Qt 界面线程安全的方法：

方法一：使用信号和槽机制
原理：信号和槽机制是 Qt 中实现线程间通信的一种安全且高效的方式。在子线程中发出信号，在主线程中连接槽函数，当信号发出时，槽函数会在主线程中执行，从而确保界面操作在主线程中进行。
示例代码：

#include <QObject> 
#include <QThread> 
#include <QDebug> 
#include <QWidget> 
#include <QLabel> 
 
class Worker : public QObject 
{{ 
    Q_OBJECT 
signals: 
    void updateLabel(const QString &text); 
public slots: 
    void doWork() 
    {{ 
        for (int i = 0; i < 5; ++i) 
        {{ 
            emit updateLabel(QString::number(i)); 
            QThread::msleep(1000); 
        }} 
    }} 
}}; 
 
class MainWidget : public QWidget 
{{ 
    Q_OBJECT 
public: 
    MainWidget(QWidget *parent = nullptr) : QWidget(parent) 
    {{ 
        label = new QLabel("Initial Text", this); 
        Worker *worker = new Worker; 
        QThread *thread = new QThread; 
        worker->moveToThread(thread); 
 
        connect(worker, &Worker::updateLabel, this, &MainWidget::onUpdateLabel); 
        connect(thread, &QThread::started, worker, &Worker::doWork); 
        connect(worker, &Worker::finished, thread, &QThread::quit); 
        connect(worker, &Worker::finished, worker, &Worker::deleteLater); 
        connect(thread, &QThread::finished, thread, &QThread::deleteLater); 
 
        thread->start(); 
    }} 
private slots: 
    void onUpdateLabel(const QString &text) 
    {{ 
        label->setText(text); 
    }} 
private: 
    QLabel *label; 
}};

方法二：使用 QMetaObject::invokeMethod()
原理：QMetaObject::invokeMethod() 函数可以在指定的线程中调用一个对象的槽函数或普通成员函数。通过指定 Qt::QueuedConnection 连接类型，可以确保函数在目标线程的事件循环中执行。
示例代码：

#include <QObject> 
#include <QThread> 
#include <QDebug> 
#include <QWidget> 
#include <QLabel> 
#include <QMetaObject> 
 
class Worker : public QObject 
{{ 
    Q_OBJECT 
public slots: 
    void doWork(QLabel *label) 
    {{ 
        for (int i = 0; i < 5; ++i) 
        {{ 
            QMetaObject::invokeMethod(label, "setText", Qt::QueuedConnection, Q_ARG(QString, QString::number(i))); 
            QThread::msleep(1000); 
        }} 
    }} 
}}; 
 
class MainWidget : public QWidget 
{{ 
    Q_OBJECT 
public: 
    MainWidget(QWidget *parent = nullptr) : QWidget(parent) 
    {{ 
        label = new QLabel("Initial Text", this); 
        Worker *worker = new Worker; 
        QThread *thread = new QThread; 
        worker->moveToThread(thread); 
 
        connect(thread, &QThread::started, [=]() {{ worker->doWork(label); }}); 
        connect(worker, &Worker::finished, thread, &QThread::quit); 
        connect(worker, &Worker::finished, worker, &Worker::deleteLater); 
        connect(thread, &QThread::finished, thread, &QThread::deleteLater); 
 
        thread->start(); 
    }} 
private: 
    QLabel *label; 
}};

方法三：使用互斥锁（QMutex）进行同步
原理：在多线程环境下，如果需要访问共享资源（如界面控件），可以使用互斥锁来确保同一时间只有一个线程可以访问该资源。但是，这种方法一般不直接用于界面操作，因为界面操作必须在主线程中进行，互斥锁主要用于保护其他共享数据。
示例代码：

#include <QObject> 
#include <QThread> 
#include <QMutex> 
#include <QDebug> 
 
class SharedData 
{{ 
public: 
    void setData(int value) 
    {{ 
        QMutexLocker locker(&mutex); 
        data = value; 
    }} 
    int getData() 
    {{ 
        QMutexLocker locker(&mutex); 
        return data; 
    }} 
private: 
    int data; 
    QMutex mutex; 
}}; 
 
class Worker : public QObject 
{{ 
    Q_OBJECT 
public slots: 
    void doWork(SharedData *sharedData) 
    {{ 
        for (int i = 0; i < 5; ++i) 
        {{ 
            sharedData->setData(i); 
            QThread::msleep(1000); 
        }} 
    }} 
}};

19. 请解释一下 Qt 中的事件循环和线程的关系，以及在多线程中事件循环是如何工作的。

（1）. 事件循环的基本概念：事件循环是 Qt 应用程序的核心机制之一，它负责处理各种事件，如鼠标点击、键盘输入、定时器事件等。在 Qt 中，每个线程都可以有自己的事件循环，主线程（GUI 线程）的事件循环负责处理与界面相关的事件，而其他线程的事件循环可以处理该线程内部的事件。

（2）. 事件循环和线程的关系：主线程的事件循环：在 Qt 应用程序启动时，会自动创建一个主线程的事件循环。主线程的事件循环负责处理与界面相关的事件，如绘制界面、处理用户输入等。所有与界面相关的操作都必须在主线程的事件循环中执行，否则可能会导致界面崩溃或出现未定义行为。
（3）. 子线程的事件循环：子线程可以通过调用 exec() 函数来启动自己的事件循环。子线程的事件循环可以处理该线程内部的事件，如定时器事件、自定义事件等。子线程的事件循环可以与主线程的事件循环进行通信，通过信号和槽机制实现线程间的事件传递。
（4）. 多线程中事件循环的工作原理：

信号和槽机制：在多线程中，信号和槽机制是实现线程间通信的主要方式。当一个信号在一个线程中发出时，根据连接类型的不同，槽函数可以在不同的线程中执行。如果连接类型为 Qt::DirectConnection，槽函数会在发出信号的线程中立即执行；如果连接类型为 Qt::QueuedConnection，槽函数会在接收对象所在的线程的事件循环中执行；如果连接类型为 Qt::BlockingQueuedConnection，则会阻塞发出信号的线程，直到槽函数执行完毕。
自定义事件：可以通过自定义事件来实现线程间的通信。在子线程中创建一个自定义事件，然后通过 QCoreApplication::postEvent() 函数将事件发送到目标对象所在的线程的事件循环中。目标对象的 event() 函数会在其所在线程的事件循环中处理该事件。
定时器事件：每个线程都可以有自己的定时器，定时器事件会在该线程的事件循环中处理。在子线程中创建定时器时，定时器事件会在子线程的事件循环中执行，而不会影响主线程的事件循环。

20. 在 Qt 多线程编程中，如何处理线程间的通信？

在 Qt 多线程编程中，线程间通信是一个重要的话题。Qt 提供了以下几种方式来处理线程间的通信：

信号槽机制：信号槽机制是 Qt 中最常用的线程间通信方式。不同线程中的对象可以通过信号槽进行通信。当一个线程中的对象发出信号时，另一个线程中的对象可以通过连接该信号到自己的槽函数来做出响应。需要注意的是，当信号和槽在不同线程中时，信号的传递会通过事件队列进行，确保线程安全。

#include <QObject> 
#include <QThread> 
 
class Sender : public QObject 
{ 
    Q_OBJECT 
signals: 
    void mySignal(int value); 
public: 
    void sendSignal() { 
        emit mySignal(42); 
    } 
}; 
 
class Receiver : public QObject 
{ 
    Q_OBJECT 
public slots: 
    void mySlot(int value) { 
        // 处理接收到的值 
    } 
}; 
 
// 使用示例 
QThread *thread = new QThread; 
Sender *sender = new Sender; 
Receiver *receiver = new Receiver; 
receiver->moveToThread(thread); 
QObject::connect(sender, &Sender::mySignal, receiver, &Receiver::mySlot); 
thread->start(); 
sender->sendSignal();

共享数据：可以通过共享数据来实现线程间的通信，但需要注意线程安全问题。可以使用互斥锁（QMutex）、读写锁（QReadWriteLock）等同步机制来保护共享数据。

#include <QObject> 
#include <QThread> 
#include <QMutex> 
 
class SharedData 
{ 
public: 
    int value; 
    QMutex mutex; 
}; 
 
class Writer : public QObject 
{ 
    Q_OBJECT 
public slots: 
    void writeData(SharedData *data) { 
        data->mutex.lock();  
        data->value = 42; 
        data->mutex.unlock();  
    } 
}; 
 
class Reader : public QObject 
{ 
    Q_OBJECT 
public slots: 
    void readData(SharedData *data) { 
        data->mutex.lock();  
        int value = data->value; 
        data->mutex.unlock();  
        // 处理读取的值 
    } 
};

使用事件：可以通过发送自定义事件来实现线程间的通信。一个线程可以创建一个自定义事件，并将其发送到另一个线程的事件队列中，另一个线程可以通过重写 event 函数来处理该事件。

21. 如何避免 Qt 多线程编程中的死锁问题？

死锁是多线程编程中常见的问题，以下是一些避免死锁的方法：

统一锁的获取顺序：在多个线程中，确保按照相同的顺序获取锁。如果线程 A 先获取锁 L1 再获取锁 L2，那么线程 B 也应该按照相同的顺序获取锁，避免出现循环等待的情况。
使用锁的超时机制：在获取锁时，可以设置一个超时时间。如果在规定的时间内无法获取到锁，则放弃获取，避免无限等待。例如，使用 QMutex::tryLock 函数可以尝试获取锁，并在一定时间内返回结果。

QMutex mutex; 
if (mutex.tryLock(1000))  { // 尝试在 1000 毫秒内获取锁 
    // 成功获取锁，执行任务 
    mutex.unlock();  
} else { 
    // 未能获取锁，处理错误 
}

减少锁的粒度：尽量减少锁的范围，只在必要的代码段中使用锁。避免在锁的保护下执行耗时的操作，减少锁的持有时间，降低死锁的概率。
使用高级同步机制：可以使用更高级的同步机制，如信号量（QSemaphore）、条件变量（QWaitCondition）等，来替代简单的互斥锁，以减少死锁的风险。

网络编程部分

22. 请介绍一下 Qt 中网络编程的主要类及功能？

Qt 提供了丰富的网络编程类，主要包括以下几个：
QTcpSocket 和 QTcpServer：用于实现 TCP 协议的客户端和服务器。
QTcpSocket：作为客户端，可以连接到服务器，发送和接收数据。通过 connectToHost 函数连接到服务器，使用 write 函数发送数据，使用 readyRead 信号和 read 函数接收数据。

#include <QTcpSocket> 
 
QTcpSocket *socket = new QTcpSocket(this); 
socket->connectToHost("127.0.0.1", 1234); 
if (socket->waitForConnected()) { 
    socket->write("Hello, server!"); 
    if (socket->waitForReadyRead()) { 
        QByteArray data = socket->readAll(); 
        // 处理接收到的数据 
    } 
}

QTcpServer：作为服务器，监听指定的端口，接受客户端的连接。通过 listen 函数开始监听，使用 newConnection 信号和 nextPendingConnection 函数获取新的客户端连接。

#include <QTcpServer> 
#include <QTcpSocket> 
 
class MyServer : public QTcpServer 
{ 
    Q_OBJECT 
protected: 
    void incomingConnection(qintptr socketDescriptor) override { 
        QTcpSocket *socket = new QTcpSocket(this); 
        socket->setSocketDescriptor(socketDescriptor); 
        // 处理客户端连接 
    } 
};

QUdpSocket：用于实现 UDP 协议的通信。可以发送和接收 UDP 数据报。通过 writeDatagram 函数发送数据报，使用 readyRead 信号和 readDatagram 函数接收数据报。

#include <QUdpSocket> 
 
QUdpSocket *socket = new QUdpSocket(this); 
QByteArray data = "Hello, UDP!"; 
socket->writeDatagram(data, QHostAddress::Broadcast, 1234); 
if (socket->waitForReadyRead()) { 
    QByteArray datagram; 
    datagram.resize(socket->pendingDatagramSize());  
    QHostAddress sender; 
    quint16 senderPort; 
    socket->readDatagram(datagram.data(),  datagram.size(),  &sender, &senderPort); 
    // 处理接收到的数据报 
}

QNetworkAccessManager：用于处理 HTTP 请求。可以发送 GET、POST 等请求，并接收服务器的响应。通过 QNetworkRequest 和 QNetworkReply 类来管理请求和响应。

#include <QNetworkAccessManager> 
#include <QNetworkRequest> 
#include <QNetworkReply> 
 
QNetworkAccessManager *manager = new QNetworkAccessManager(this); 
QNetworkRequest request(QUrl("http://example.com"));  
QNetworkReply *reply = manager->get(request); 
connect(reply, &QNetworkReply::finished, [=]() { 
    if (reply->error() == QNetworkReply::NoError) { 
        QByteArray data = reply->readAll(); 
        // 处理响应数据 
    } 
    reply->deleteLater(); 
});

23. 在 Qt 网络编程中，如何处理网络延迟和丢包问题？

在 Qt 网络编程中，网络延迟和丢包是常见的问题，可以采取以下措施来处理：

超时处理：设置合理的超时时间，避免长时间等待。例如，在使用 QTcpSocket 或 QUdpSocket 时，可以使用 waitForConnected、waitForReadyRead 等函数设置超时时间。如果在规定的时间内没有完成相应的操作，则认为发生了网络延迟或丢包，进行相应的错误处理。

QTcpSocket *socket = new QTcpSocket(this); 
socket->connectToHost("127.0.0.1", 1234); 
if (!socket->waitForConnected(3000)) { // 等待 3 秒 
    // 处理连接超时 
}

重传机制：对于重要的数据，可以采用重传机制。当发送数据后，在一定时间内没有收到确认信息时，重新发送数据。可以使用定时器来实现重传功能。

#include <QTimer> 
 
class MySender : public QObject 
{ 
    Q_OBJECT 
public: 
    MySender(QObject *parent = nullptr) : QObject(parent) { 
        timer = new QTimer(this); 
        connect(timer, &QTimer::timeout, this, &MySender::retransmit); 
    } 
 
    void sendData(const QByteArray &data) { 
        // 发送数据 
        // ... 
        timer->start(5000); // 启动定时器，5 秒后重传 
    } 
 
private slots: 
    void retransmit() { 
        // 重传数据 
        // ... 
        timer->start(5000); // 再次启动定时器 
    } 
 
private: 
    QTimer *timer; 
};

数据校验：在发送数据时，可以添加校验信息，如 CRC 校验码。接收方在接收到数据后，通过计算校验码来验证数据的完整性。如果校验失败，则认为数据发生了丢包或错误，要求发送方重新发送数据。
拥塞控制：在网络拥塞时，适当降低数据发送的速率，避免进一步加重网络负担。可以根据网络的状态动态调整发送速率，例如使用滑动窗口协议来控制数据的发送量。

24. 谈谈 Qt 中 SSL/TLS 加密通信的实现方法？

在 Qt 中实现 SSL/TLS 加密通信可以使用 QSslSocket 类，以下是实现步骤：

#include <QSslSocket> 
 //创建 QSslSocket 对象
QSslSocket *socket = new QSslSocket(this); 
//连接到服务器
socket->connectToHostEncrypted("example.com",  443); 
//处理 SSL/TLS 握手：可以通过 QSslSocket 的 sslErrors 信号来处理 SSL/TLS 握手过程中出现的错误
connect(socket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(handleSslErrors(const QList<QSslError>));