工业软件架构3:(QT和C++实现)

工业软件架构 - 事件驱动 - 3

  • [1. 并行复杂任务](#1. 并行复杂任务)
    • [1.1 使用 QThreadPool 和 QRunnable 进行任务并行化](#1.1 使用 QThreadPool 和 QRunnable 进行任务并行化)
    • [1.2 使用 QFuture 和 QFutureWatcher 进行异步任务管理](#1.2 使用 QFuture 和 QFutureWatcher 进行异步任务管理)
    • [1.3 结合命令模式](#1.3 结合命令模式)
    • [1.4 错误处理与状态更新](#1.4 错误处理与状态更新)
    • [1.5 总结](#1.5 总结)
  • [2. 多线程任务](#2. 多线程任务)
    • [2.1. 任务类型和线程的划分](#2.1. 任务类型和线程的划分)
    • [2.2 监控任务的处理](#2.2 监控任务的处理)
    • [2.3 复杂任务的并行处理](#2.3 复杂任务的并行处理)
    • [2.4. 管理和协调多个线程](#2.4. 管理和协调多个线程)
    • [2.5 使用 QWaitCondition 和 QMutex 控制任务执行](#2.5 使用 QWaitCondition 和 QMutex 控制任务执行)
      • [QWaitCondition 和 QMutex 是 Qt 提供的用于线程同步的工具。](#QWaitCondition 和 QMutex 是 Qt 提供的用于线程同步的工具。)
    • [2.6 管理监控线程的生命周期](#2.6 管理监控线程的生命周期)
    • [2.5 总结](#2.5 总结)

1. 并行复杂任务

当某些耗时操作本身需要开几个子线程来完成,通常意味着这些操作非常复杂,可能涉及多步计算或并行处理。

在这种情况下,需要更加精细地管理线程,以确保操作的并发性和主线程的响应性。以下是处理这种情况的推荐方法和架构设计。

1.1 使用 QThreadPool 和 QRunnable 进行任务并行化

QThreadPool 和 QRunnable 是 Qt 提供的工具,用于高效地管理并发任务。你可以将耗时操作的不同步骤封装为独立的任务,并将它们提交给 QThreadPool 来并行执行。

假设我们有一个复杂的操作需要同时处理多个子任务,每个子任务都需要在不同的线程中运行。

cpp 复制代码
class ComplexTask : public QRunnable 
{
public:
    ComplexTask(int taskId) : taskId(taskId) {}

    void run() override 
    {
        // 模拟耗时任务
        qDebug() << "Task" << taskId << "started.";
        QThread::sleep(2);  // 模拟长时间运行
        qDebug() << "Task" << taskId << "completed.";
    }

private:
    int taskId;
};

主任务可以将多个 ComplexTask 提交给 QThreadPool 来并行执行:

cpp 复制代码
class ComplexOperation : public QObject {
    Q_OBJECT

public:
    ComplexOperation(QObject *parent = nullptr) : QObject(parent) {}

    void execute() 
    {
        QThreadPool *pool = QThreadPool::globalInstance();
        for (int i = 0; i < 5; ++i) 
        {
            pool->start(new ComplexTask(i));
        }

        // 等待所有任务完成(可选)
        pool->waitForDone();
        emit operationCompleted();
    }

signals:
    void operationCompleted();
};

1.2 使用 QFuture 和 QFutureWatcher 进行异步任务管理

QFuture 和 QFutureWatcher 提供了一种更高级的方式来管理和监控异步任务,特别适合在主线程中等待或监听多个子线程任务的完成状态。

cpp 复制代码
class ParallelTaskManager : public QObject
 {
    Q_OBJECT

public:
    ParallelTaskManager(QObject *parent = nullptr) : QObject(parent) {}

    void executeComplexOperation() 
    {
        QVector<QFuture<void>> futures;
        for (int i = 0; i < 5; ++i)
         {
            QFuture<void> future = QtConcurrent::run(this, &ParallelTaskManager::performTask, i);
            futures.append(future);
        }

        QFutureWatcher<void> *watcher = new QFutureWatcher<void>(this);
        connect(watcher, &QFutureWatcher<void>::finished, this, &ParallelTaskManager::onAllTasksCompleted);
        watcher->setFuture(QtConcurrent::run([futures]()
         {
            for (auto &future : futures) 
            {
                future.waitForFinished();
            }
        }));
    }
private:
    void performTask(int taskId)
     {
        qDebug() << "Performing task" << taskId;
        QThread::sleep(2);  // 模拟耗时任务
        qDebug() << "Task" << taskId << "done";
    }

private slots:
    void onAllTasksCompleted()
     {
        qDebug() << "All tasks completed.";
        emit complexOperationCompleted();
    }
    
signals:
    void complexOperationCompleted();
};

1.3 结合命令模式

在这种复杂场景中,结合命令模式可以有效地组织代码,确保任务执行的灵活性和可维护性。命令对象可以封装任务的执行逻辑,包括启动多个子线程的操作。

cpp 复制代码
class ComplexOperationCommand : public Command 
{
public:
    ComplexOperationCommand(ParallelTaskManager *taskManager)
        : taskManager(taskManager) {}

    void execute() override
     {
        taskManager->executeComplexOperation();
    }

private:
    ParallelTaskManager *taskManager;
};

1.4 错误处理与状态更新

在处理多个并行任务时,还需要考虑如何处理错误和更新任务状态。可以使用信号与槽机制来实现任务的状态监控与错误处理。

cpp 复制代码
void ParallelTaskManager::executeComplexOperation()
 {
    QVector<QFuture<void>> futures;
    for (int i = 0; i < 5; ++i) 
    {
        QFuture<void> future = QtConcurrent::run(this, &ParallelTaskManager::performTask, i);
        futures.append(future);
    }

    QFutureWatcher<void> *watcher = new QFutureWatcher<void>(this);
    connect(watcher, &QFutureWatcher<void>::finished, this, &ParallelTaskManager::onAllTasksCompleted);
    connect(watcher, &QFutureWatcher<void>::progressValueChanged, this, &ParallelTaskManager::onTaskProgress);
    watcher->setFuture(QtConcurrent::run([futures]()
     {
        for (auto &future : futures)
         {
            future.waitForFinished();
        }
    }));
}

void ParallelTaskManager::onTaskProgress(int progress) 
{
    // 更新进度或处理错误
    qDebug() << "Task progress:" << progress;
}

1.5 总结

  • QThreadPool 和 QRunnable: 适合简单的并行任务管理,直接将任务分配给线程池执行。
  • QFuture 和 QFutureWatcher: 提供了更高级的任务监控和管理方式,适合需要监听任务完成状态的场景。
  • 命令模式: 可以将复杂的任务逻辑封装为命令对象,结合线程池或异步任务框架执行,增强代码的可维护性。
  • 错误处理与状态监控: 通过信号与槽机制实时监控任务状态,处理错误,确保系统的稳定性和响应性。

2. 多线程任务

当几个子线程执行不同的操作,甚至包含类似监控子线程的任务时,设计和管理这些线程的方式会更加复杂。下面是如何处理这种情况的推荐架构设计:

2.1. 任务类型和线程的划分

首先,明确每个子线程的任务类型。这些任务可能包括:

  • 计算任务: 耗时计算或数据处理任务,需要在后台线程中执行。
  • I/O 任务: 文件读取、网络请求等 I/O 密集型任务。
  • 监控任务: 持续运行的任务,例如传感器状态监控、硬件状态监控。

根据任务的不同性质,将线程划分为以下几类:

  • 短期任务线程: 适用于一次性执行的计算或 I/O 任务,完成后即可销毁线程。
  • 长期任务线程(监控线程): 持续运行的线程,负责实时监控系统状态或数据变化。
  • 线程池任务: 使用线程池管理的任务,适合多个并行的短期任务。

2.2 监控任务的处理

对于监控任务,通常需要使用 QThread 来创建一个专用的线程类,该线程会在后台持续运行,并定期执行监控操作。

cpp 复制代码
class MonitoringThread : public QThread 
{
    Q_OBJECT

public:
    MonitoringThread(QObject *parent = nullptr) : QThread(parent) {}
protected:
    void run() override 
    {
        while (!isInterruptionRequested())
         {
            // 执行监控操作
            monitorSensors();
            QThread::sleep(1);  // 每秒执行一次监控操作
        }
    }

private:
    void monitorSensors()
     {
        // 模拟传感器监控逻辑
        qDebug() << "Monitoring sensors...";
    }
};

启动和管理这个监控线程:

cpp 复制代码
MonitoringThread *monitorThread = new MonitoringThread();
monitorThread->start();

2.3 复杂任务的并行处理

对于复杂任务,需要在命令模式中进行封装,并将这些任务分配给不同的子线程执行。

示例:

假设有一个复杂的操作需要并行执行多个子任务:

cpp 复制代码
class SubTask1 : public QRunnable 
{
public:
    void run() override 
    {
        // 执行子任务 1
        qDebug() << "SubTask 1 executing...";
        QThread::sleep(2);
        qDebug() << "SubTask 1 completed.";
    }
};

class SubTask2 : public QRunnable
 {
public:
    void run() override
     {
        // 执行子任务 2
        qDebug() << "SubTask 2 executing...";
        QThread::sleep(3);
        qDebug() << "SubTask 2 completed.";
    }
};

class ComplexOperationCommand : public Command
 {
public:
    void execute() override 
    {
        QThreadPool *pool = QThreadPool::globalInstance();
        pool->start(new SubTask1());
        pool->start(new SubTask2());

        // 等待所有任务完成(可选)
        pool->waitForDone();
        qDebug() << "All sub-tasks completed.";
    }
};

2.4. 管理和协调多个线程

当有多个不同类型的线程在运行时,需要确保线程之间的协调和资源管理。以下是一些推荐的管理方法:

使用信号与槽进行线程间通信

在 Qt 中,使用信号与槽机制可以轻松实现线程之间的通信,避免线程安全问题。

cpp 复制代码
class MonitoringThread : public QThread 
{
    Q_OBJECT

signals:
    void sensorDataUpdated(int sensorId, double value);

protected:
    void run() override
     {
        while (!isInterruptionRequested())
         {
            double value = monitorSensors();
            emit sensorDataUpdated(1, value);
            QThread::sleep(1);
        }
    }

private:
    double monitorSensors() 
    {
        // 返回模拟传感器数据
        return qrand() % 100 / 10.0;
    }
};

2.5 使用 QWaitCondition 和 QMutex 控制任务执行

当你有多个线程需要按照严格的顺序执行时,可以使用 QMutex 来保护共享资源,并使用 QWaitCondition 让一个线程等待另一个线程的完成信号。这种机制确保了多个线程能够按照你期望的顺序运行。

QWaitCondition 和 QMutex 是 Qt 提供的用于线程同步的工具。

  • QMutex: 互斥锁,用于保护共享资源,确保在多线程环境中,只有一个线程可以访问某一共享资源。
  • QWaitCondition: 条件变量,用于线程间的协调。它可以让一个线程等待某个条件的满足,并在条件满足时通知线程继续执行。

示例:三个需要严格顺序执行的任务

假设我们有三个任务 Task1、Task2 和 Task3,它们需要严格按顺序执行。即 Task1 必须在 Task2 之前完成,而 Task2 必须在 Task3 之前完成。

  1. 任务类定义
    首先,我们定义每个任务类,这些任务将通过 QRunnable 来运行:

    cpp 复制代码
    #include <QCoreApplication>
    #include <QThreadPool>
    #include <QRunnable>
    #include <QWaitCondition>
    #include <QMutex>
    #include <QMutexLocker>
    #include <QDebug>
    
    // 任务1
    class Task1 : public QRunnable
     {
    public:
    	Task1(QMutex *mutex, QWaitCondition *cond1)
       		: mutex(mutex), cond1(cond1) {}
    
    	void run() override
    	 {
        	QMutexLocker locker(mutex);
        	qDebug() << "Task 1 started";
        	QThread::sleep(1);  // 模拟任务1耗时
        	qDebug() << "Task 1 completed";
        	cond1->wakeOne();  // 通知任务2可以开始了
    	}
    
    private:
    	QMutex *mutex;
    	QWaitCondition *cond1;
    };
    
    // 任务2
    class Task2 : public QRunnable
     {
    public:
    	Task2(QMutex *mutex, QWaitCondition *cond1, QWaitCondition *cond2)
        	: mutex(mutex), cond1(cond1), cond2(cond2) {}
    
    	void run() override 
    	{
        	QMutexLocker locker(mutex);
        	cond1->wait(mutex);  // 等待任务1完成
        	qDebug() << "Task 2 started";
        	QThread::sleep(1);  // 模拟任务2耗时
        	qDebug() << "Task 2 completed";
        	cond2->wakeOne();  // 通知任务3可以开始了
    	}
    
    private:
    	QMutex *mutex;
    	QWaitCondition *cond1;
    	QWaitCondition *cond2;
    };
    
    // 任务3
    class Task3 : public QRunnable
     {
    public:
    	Task3(QMutex *mutex, QWaitCondition *cond2)
        	: mutex(mutex), cond2(cond2) {}
    
    	void run() override 
    	{
        	QMutexLocker locker(mutex);
       		cond2->wait(mutex);  // 等待任务2完成
        	qDebug() << "Task 3 started";
        	QThread::sleep(1);  // 模拟任务3耗时
       		qDebug() << "Task 3 completed";
    	}
    
    private:
    	QMutex *mutex;
    	QWaitCondition *cond2;
    };
    1. 任务执行
      在主程序中,我们使用 QThreadPool 来启动这些任务,并确保它们按顺序执行。
    cpp 复制代码
    int main(int argc, char *argv[])
     {
    	QCoreApplication a(argc, argv);
    
    	QMutex mutex;
    	QWaitCondition cond1, cond2;
    
    	QThreadPool *pool = QThreadPool::globalInstance();
    
    	// 创建任务并设置顺序
    	Task1 *task1 = new Task1(&mutex, &cond1);
    	Task2 *task2 = new Task2(&mutex, &cond1, &cond2);
    	Task3 *task3 = new Task3(&mutex, &cond2);
    
    	// 提交任务到线程池
    	pool->start(task1);
    	pool->start(task2);
    	pool->start(task3);
    	return a.exec();
    }
    1. 运行原理
      Task1: 首先启动,完成后通过 cond1->wakeOne() 唤醒 Task2。
      Task2: 在 Task1 完成后开始执行,等待 cond1 条件满足,完成后通过 cond2->wakeOne() 唤醒 Task3。
      Task3: 在 Task2 完成后开始执行,等待 cond2 条件满足,然后开始执行。

2.6 管理监控线程的生命周期

在应用程序退出时,确保所有监控线程正确终止,以避免资源泄漏或线程悬挂。

cpp 复制代码
// 在程序退出时终止监控线程
monitorThread->requestInterruption();
monitorThread->wait();  // 等待线程安全退出
delete monitorThread;

2.5 总结

  • 监控任务: 使用 QThread 实现长期运行的监控任务,专门的监控线程能够在后台持续运行,并定期执行检查。
  • 复杂操作: 使用 QThreadPool 或 QtConcurrent::run 处理并行的复杂操作,将多个子任务分配给不同的线程运行。
  • 线程间通信: 通过信号与槽机制实现线程间的通信和数据同步,避免线程安全问题。
  • 线程管理: 使用 QWaitCondition 和 QMutex 协调任务执行顺序,并在程序退出时安全终止所有监控线程。
相关推荐
懒大王爱吃狼39 分钟前
Python教程:python枚举类定义和使用
开发语言·前端·javascript·python·python基础·python编程·python书籍
秃头佛爷2 小时前
Python学习大纲总结及注意事项
开发语言·python·学习
待磨的钝刨2 小时前
【格式化查看JSON文件】coco的json文件内容都在一行如何按照json格式查看
开发语言·javascript·json
XiaoLeisj4 小时前
【JavaEE初阶 — 多线程】单例模式 & 指令重排序问题
java·开发语言·java-ee
励志成为嵌入式工程师5 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉5 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer5 小时前
【C++】vector 类深度解析:探索动态数组的奥秘
开发语言·c++·算法
Peter_chq5 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
记录成长java7 小时前
ServletContext,Cookie,HttpSession的使用
java·开发语言·servlet
前端青山7 小时前
Node.js-增强 API 安全性和性能优化
开发语言·前端·javascript·性能优化·前端框架·node.js