qt 队列和线程

科学的发展-只不过是读大自然写的代码

已于 2024-08-29 14:37:53 修改

阅读量1k

点赞数 21

分类专栏： # qt-线程文章标签： qt 开发语言队列线程

于 2024-07-12 08:51:39 首次发布

本文链接：https://blog.csdn.net/xie__jin__cheng/article/details/140368794

版权

qt-线程专栏收录该内容

15 篇文章 0 订阅

订阅专栏

1.qt 队列应用

概要

这里采用定周期检查任务的方式来处理队列，虽然没有分线程，但和大部分队列任务的处理方式相同，因为队列最主要的价值就是对任务的排队，所以这种方式是一种很常用的场景。

开始

Qt 队列应用通常涉及到在 Qt 程序中使用队列数据结构来处理一系列的任务或数据。Qt 本身并没有直接提供队列类，但你可以使用 STL（Standard Template Library）中的 std::queue 或者 Qt 的容器类如 QList 或 QVector 来模拟队列行为。

以下是一个简单的 Qt 队列应用的示例，它使用 QList 来模拟一个队列，并通过 Qt 的信号和槽机制来处理队列中的任务：

定义队列和任务处理类

首先，你可以定义一个任务处理类，该类将包含处理任务的方法和一个用于存储任务的队列。

#include <QList>  
#include <QObject>  
  
class TaskProcessor : public QObject {  
    Q_OBJECT  
  
public:  
    TaskProcessor() {}  
  
    void enqueueTask(const QString& task) {  
        taskQueue.append(task);  
        processQueue();  
    }  
  
private slots:  
    void processTask() {  
        if (!taskQueue.isEmpty()) {  
            QString task = taskQueue.takeFirst();  
            // 处理任务，例如打印任务内容  
            qDebug() << "Processing task:" << task;  
            // 假设每个任务需要一些时间来完成  
            QThread::sleep(1); // 模拟耗时操作  
            processQueue(); // 处理下一个任务  
        }  
    }  
  
    void processQueue() {  
        if (!taskQueue.isEmpty() && !isProcessing) {  
            isProcessing = true;  
            QTimer::singleShot(0, this, SLOT(processTask()));  
        } else {  
            isProcessing = false;  
        }  
    }  
  
private:  
    QList<QString> taskQueue;  
    bool isProcessing = false;  
};

在 Qt 应用程序中使用队列处理类

然后，在你的 Qt 应用程序中，你可以创建 TaskProcessor 的实例，并向其队列中添加任务。

#include <QCoreApplication>  
#include <QDebug>  
#include "taskprocessor.h"  
  
int main(int argc, char* argv[]) {  
    QCoreApplication app(argc, argv);  
  
    TaskProcessor processor;  
    processor.enqueueTask("Task 1");  
    processor.enqueueTask("Task 2");  
    processor.enqueueTask("Task 3");  
  
    return app.exec();  
}

这个示例展示了如何在 Qt 应用程序中使用队列来处理一系列的任务。TaskProcessor 类使用 QList 作为任务队列，并通过 Qt 的信号和槽机制来异步处理这些任务。当一个新的任务被添加到队列中时，它会触发队列的处理流程。每个任务被依次从队列中取出并处理。这个模式可以用于处理各种后台任务，如文件处理、网络请求等。

2.c++ 队列

在C++中，队列是一种常见的数据结构，用于按照元素被添加的顺序来保存和访问元素。C++标准库中的<queue>头文件提供了一个队列容器适配器std::queue，它给予程序员一种使用队列的方式，而无需关心底层的具体实现。

下面是一个简单的示例，展示了如何在C++中使用std::queue：

#include <iostream>  
#include <queue>  
#include <string>  
  
int main() {  
    std::queue<std::string> myQueue;  
  
    // 向队列中添加元素  
    myQueue.push("Apple");  
    myQueue.push("Banana");  
    myQueue.push("Cherry");  
  
    // 访问队列的头部元素，但不移除它  
    std::cout << "Front element: " << myQueue.front() << std::endl;  
  
    // 移除并访问队列的头部元素  
    std::cout << "Popped element: " << myQueue.front() << std::endl;  
    myQueue.pop();  
  
    // 再次访问队列的头部元素  
    std::cout << "New front element: " << myQueue.front() << std::endl;  
  
    // 检查队列是否为空  
    if (!myQueue.empty()) {  
        std::cout << "Queue is not empty. Size: " << myQueue.size() << std::endl;  
    }  
  
    // 遍历并移除队列中的所有元素  
    while (!myQueue.empty()) {  
        std::cout << "Processing: " << myQueue.front() << std::endl;  
        myQueue.pop();  
    }  
  
    return 0;  
}

在上面的代码中，我们首先包含了<iostream>和<queue>头文件，并使用了std::string作为队列中存储的数据类型。然后，我们创建了一个std::queue<std::string>对象myQueue，并向其中添加了三个字符串元素。

我们使用front()成员函数来访问队列的头部元素（即最早添加的元素），但并不会从队列中移除它。要移除并访问头部元素，我们使用pop()成员函数。empty()成员函数用于检查队列是否为空，而size()成员函数则返回队列中的元素数量。

最后，我们使用一个循环来遍历并移除队列中的所有元素，直到队列为空。

请注意，std::queue是一个容器适配器，它通常使用std::deque作为底层容器，但你也可以指定其他类型的底层容器，如std::list或自定义容器，只要它们满足特定的接口要求。然而，在大多数情况下，使用默认的std::deque就足够了。

3.QTimer::singleShot

QTimer::singleShot 是 Qt 框架中的一个静态函数，用于在指定的时间后执行一个槽函数，但只执行一次。它常用于在特定延迟后触发某个动作，而无需创建一个持久的 QTimer 对象。

函数的基本用法如下：

QTimer::singleShot(int msec, QObject *receiver, const char *member);

msec: 延迟的毫秒数。
receiver: 要接收信号的对象的指针。
member: 要调用的槽函数的签名。

例如，如果你想在 500 毫秒后执行一个名为 mySlotFunction 的槽函数，你可以这样写：

QTimer::singleShot(500, this, SLOT(mySlotFunction()));

或者使用新的信号和槽语法（如果你的 Qt 版本支持）：

QTimer::singleShot(500, this, &MyClass::mySlotFunction);

其中 MyClass 是包含 mySlotFunction 的类的名称。

这种方法比创建一个 QTimer 对象，设置其间隔，然后连接其 timeout() 信号到槽函数要简洁得多，特别是当你只需要执行一次延迟操作时。

4.线程中，定周期执行一个函数，和用while(true)+Thread::sleep(时间) 那个的性能更好

在线程中定期执行一个函数，有两种常见的方法：

使用定时器（如 QTimer 在 Qt 中，或 java.util.Timer 在 Java 中）来周期性地触发函数。
使用 while(true) 循环结合 Thread::sleep(时间) （或类似机制，如在 Java 中的 Thread.sleep(时间)）。

比较这两种方法的性能时，需要考虑多个方面：

1. 精确性与可靠性

定时器：通常能提供较为精确的触发时间，且不受系统负载或其他线程的影响。定时器通常是由操作系统内核管理的，因此其触发相对可靠。
while(true) + sleep：这种方法受系统调度和线程优先级的影响较大。如果系统负载高，sleep 时间可能会受到影响，导致实际执行间隔与预期有所偏差。

2. 资源消耗

定时器：通常只在需要时触发，不占用额外的 CPU 时间。
while(true) + sleep：即使线程在 sleep，也会占用一定的系统资源，尤其是当线程数量较多时。

3. 编程简便性

定时器：提供了简洁的 API 来设置定时任务和回调函数，易于管理和维护。
while(true) + sleep：需要手动管理循环和休眠时间，代码相对复杂，且容易出错。

4. 灵活性

定时器：通常提供了丰富的配置选项，如单次触发、重复触发、触发时间等。
while(true) + sleep：需要更多的手动控制，但也可以实现更复杂的逻辑。

性能结论

从性能角度来看，使用定时器通常更加高效和可靠。定时器由底层系统支持，能够更精确地控制执行时间，且在不需要执行时不会消耗额外的 CPU 资源。而 while(true) + sleep 方法则可能在系统负载较高时出现时间偏差，且即使在休眠期间也会占用一定资源。

然而，在某些特定场景下，while(true) + sleep 可能提供更大的灵活性，尤其是当需要执行更复杂的调度逻辑时。但总的来说，如果只是需要定期执行某个函数，使用定时器通常是更好的选择。

5.thread::sleep是否会消耗线程的性能

Thread::sleep（或在其他编程语言中的等效方法，如Java中的Thread.sleep）确实会对线程性能产生一定影响，但这种影响主要体现在线程挂起期间不执行任何有用的工作，而不是直接消耗大量的CPU资源。以下是关于Thread::sleep对线程性能影响的几点说明：

线程挂起：当线程调用sleep方法时，它会被挂起，即暂停执行，直到指定的睡眠时间过去。在这段时间内，线程不会执行任何计算或处理工作，因此从某种程度上讲，这是对线程性能的“消耗”，因为线程在睡眠期间不做任何有用的工作。
不消耗CPU资源：尽管线程被挂起，但Thread::sleep不会让CPU忙于等待。实际上，当线程睡眠时，它不会占用CPU时间片，这意味着CPU可以处理其他任务。因此，从CPU资源消耗的角度来看，Thread::sleep并不直接导致性能下降。
上下文切换：当线程从睡眠状态唤醒并重新获得CPU时间片时，会发生上下文切换。上下文切换本身会有一定的性能开销，因为操作系统需要保存和恢复线程的执行上下文。然而，这种开销通常是微不足道的，除非上下文切换的频率非常高。
调度延迟：线程唤醒后，它可能需要等待操作系统调度器分配CPU时间片。这种调度延迟可能导致线程在预期的时间之后才能继续执行，这可以被视为一种性能影响。
代码设计和效率：如果代码中频繁使用Thread::sleep进行等待或同步，可能会导致代码效率低下。更好的做法是使用适当的同步机制（如锁、条件变量、信号量等）来协调线程间的操作，以减少不必要的等待和睡眠。