除了消息队列，以下这些高级技术也可用于获取线程执行结果

除了消息队列，以下这些高级技术也可用于获取线程执行结果：

1. 基于共享内存（Shared Memory）与内存映射文件（Memory-Mapped Files）

共享内存机制：
- 共享内存允许不同进程（包括由线程池启动的不同线程所在的进程）直接访问同一块内存区域，从而实现高效的数据共享。在获取线程执行结果方面，可以定义一个共享内存区域来存储线程执行的结果。
- 例如，在Linux系统下，可以使用shmget、shmat等系统调用实现共享内存的创建、挂载等操作。以下是一个简单示例的伪代码思路：

#include <sys/types.h>
#include <sys/shm.h>
#include <stdio.h>

// 定义共享内存结构体来存储结果
struct SharedResult {
    int taskId;
    int result;
};

int main(int argc, char *argv[]) {
    // 创建共享内存段
    int shmid = shmget(IPC_PRIVATE, sizeof(SharedResult), IPC_CREAT | 0666);
    if (shmid < 0) {
        perror("shmget");
        return -1;
    }

    // 将共享内存段挂载到进程地址空间
    struct SharedResult *sharedResult = (struct SharedResult *)shmat(shmid, NULL, 0);
    if (sharedResult == (void *)-1) {
        perror("shmat");
        return -1;
    }

    QThreadPool pool;
    pool.setMaxThreadCount(3);

    // 创建多个可运行对象实例并添加到线程池启动线程执行任务
    for (int i = 1; i <= 5; ++i) {
        MyRunnable *runnable = new MyRunnable(i, sharedResult);
        pool.start(runnable);
    }

    // 等待所有任务完成
    pool.waitForDone();

    // 从共享内存读取结果
    for (int i = 1; i <= 5; ++i) {
        printf("获取到任务 %d 的结果：%d\n", sharedResult->taskId, sharedResult->result);
    }

    // 分离共享内存段
    if (shmdt(sharedResult) < 0) {
        perror("shmdt");
        return -1;
    }

    // 删除共享内存段
    if (shmctl(shmid, IPC_RMID, NULL) < 0) {
        perror("shmctl");
        return -1;
    }

    return 0;
}

- 在上述示例中，首先创建了共享内存段并挂载到进程地址空间，然后将共享内存区域的指针传递给每个可运行对象实例（假设`MyRunnable`类构造函数接受这个指针），线程在执行任务完成后将结果写入共享内存区域。最后，在主线程中从共享内存读取结果，并进行相应的清理操作（分离和删除共享内存段）。

内存映射文件：
- 内存映射文件是一种将文件内容映射到进程内存空间的技术，使得对文件的操作如同对内存的操作一样便捷。它也可以用于获取线程执行结果，通过将线程执行结果写入到一个特定的文件中，然后在主线程中通过内存映射的方式读取该文件来获取结果。
- 例如，在Linux系统下，可以使用mmap系统调用实现内存映射文件操作。以下是一个简单示例的伪代码思路：

#include <sys/types.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <stdio.h>

// 定义结构体来存储结果（假设结果写入文件）
struct FileResult {
    int taskId;
    int result;
};

int main(int argc, char *argv[]) {
    // 创建一个临时文件用于存储结果
    int fd = open("temp_result_file", O_CREAT | O_RDWR, 0666);
    if (fd < 0) {
        perror("open");
        return -1;
    }

    // 将文件映射到内存空间
    struct FileResult *fileResult = (struct FileResult *)mmap(NULL, sizeof(FileResult) * 5, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (fileResult == (void *)-1) {
        perror("mmap");
    =-1;
    }

    QThreadPool pool;
    pool.setMaxThreadCount(3);

    // 创建多个可运行对象实例并添加到线程池启动线程执行任务
    for (int i = 1; i <= 5; ++i) {
        MyRunnable *runnable = new MyRunnable(i, fileResult);
        pool.start(runnable);
    }

    // 等待所有任务完成
    pool.waitForDone();

    // 从内存映射文件读取结果
    for (int i = 1; i <= 5; ++i) {
        printf("获取到任务 %d 的结果：%d\n", fileResult->taskId, fileResult->result);
    }

    // 解除内存映射
    if (munmap(fileResult, sizeof(FileResult) * 5) < 0) {
        perror("munmap");
        return -1;
    }

    // 关闭文件
    if (close(fd) < 0) {
        perror("close");
        return -1;
    }

    // 删除临时文件（可选）
    remove("temp_result_file");

    return 0;
}

- 在上述示例中，首先创建了一个临时文件并将其映射到内存空间，然后将内存映射区域的指针传递给每个可运行对象实例（假设`MyRunnable`类构造函数接受这个指针），线程在执行任务完成后将结果写入内存映射文件区域。最后，在主线程中从内存映射文件读取结果，并进行相应的清理操作（解除内存映射、关闭文件和删除临时文件）。

2. 基于事件驱动架构（Event-Driven Architecture）

原理及基本构成：
- 事件驱动架构以事件为核心，当某个事件发生时，相关的处理逻辑被触发。在获取线程执行结果的场景下，可以将线程执行完成作为一个事件，通过注册相应的事件处理函数来获取并处理结果。
- 通常由事件源（如线程执行完成）、事件队列（用于暂存发生的事件）、事件处理器（处理事件的逻辑）等组成。
示例实现：
- 首先定义事件结构体和事件处理器函数类型：

#include <functional>

// 定义事件结构体，这里表示线程执行完成事件
struct ThreadFinishEvent {
    int taskId;
    int result;
};

// 定义事件处理器函数类型
using EventHandler = std::function<void(const ThreadFinishEvent&)>;

- 然后，在可运行对象类（如`MyRunnable`）的`run`方法中，执行完任务后触发事件：

class MyRunnable : public QRunnable {
public:
    MyRunnable(int taskId, EventHandler handler) : m_taskId(taskId), m_handler(handler) {}

    void run() override {
        // 模拟执行任务，这里简单进行一个数学计算
        int result = m_taskId * 2;

        // 触发线程执行完成事件
        ThreadFinishEvent event = {m_taskId, result};
        m_handler(event);

        qDebug() << "线程 " << QThread::currentThreadId() << " 完成任务 " << m_taskId;
    }

private:
    int m_taskId;
    EventHandler m_handler;
};

- 最后，在主线程中注册事件处理函数并启动线程执行任务：

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

    QThreadPool pool;
    pool.setMaxThreadCount(3);

    // 注册事件处理函数
    EventHandler handler = [](const ThreadFinishEvent& event) {
        printf("获取到任务 %d 的结果：%d\n", event.taskId, event.result);
    };

    // 创建多个可运行对象实例并添加到线程池启动线程执行任务
    for (int i = 1; i <= 5; ++i) {
        MyRunnable *runnable = new MyRunnable(i, handler);
        pool.start(runnable);
    }

    // 等待所有任务完成
    pool.waitForDone();

    qDebug() > "所有任务已完成，程序即将退出";

    return a.exec();
}

- 在上述示例中，通过定义事件结构体和事件处理器函数类型，在可运行对象类中触发事件，以及在主线程中注册事件处理函数，实现了以事件驱动的方式获取线程执行结果。

3. 基于分布式系统相关技术（如RPC、分布式锁等）

远程过程调用（RPC）：
- RPC允许一台计算机上的程序调用另一台计算机上的程序中的函数，就好像调用本地函数一样。在获取线程执行结果方面，如果线程执行任务分布在不同的计算机上（例如在分布式计算环境下），可以利用RPC来获取结果。
- 例如，使用gRPC（Google Remote Procedure Call）等框架，首先需要定义服务接口和消息格式。假设我们定义一个简单的服务接口用于获取线程执行结果：

import "google/protobuf/any.proto";

service ResultService {
    rpc GetResult(google/protobuf/any.proto.Any) returns (google/protobuf/any.proto.Any);
}

- 然后，在可运行对象类（如`MyRunnable`）执行完任务后，通过RPC调用将结果发送到指定的服务端，由服务端进行存储和管理。在主线程中，通过再次调用RPC从服务端获取结果。具体实现涉及到更多的框架相关配置和代码编写，这里仅展示基本思路。

分布式锁：
- 分布式锁用于在分布式系统中协调多个进程或线程对共享资源的访问。在获取线程执行结果的场景下，可以利用分布式锁来确保只有一个线程或进程能够获取到最新的结果，避免结果的混乱。
- 例如，使用etcd（一个分布式键值存储系统）或Zookeeper等工具来实现分布式锁。假设我们使用etcd，首先需要安装和配置etcd，然后在可运行对象类中，执行完任务后尝试获取分布式锁，将结果写入到一个共享的键值存储中（通过etcd的API），然后释放分布式锁。在主线程中，通过查询etcd的键值存储来获取结果。同样，具体实现涉及到更多的工具相关配置和代码编写，这里仅展示基本思路。

这些高级技术在不同的场景下各有优劣，可以根据具体的项目需求、性能要求和开发团队的熟悉程度等因素来选择合适的方法来获取线程执行结果。

posted @ 2024-11-10 00:20 MarsCactus 阅读(5) 评论(0) 编辑收藏举报

刷新页面返回顶部

DesertCactus

除了消息队列，以下这些高级技术也可用于获取线程执行结果

1. 基于共享内存（Shared Memory）与内存映射文件（Memory-Mapped Files）

2. 基于事件驱动架构（Event-Driven Architecture）

3. 基于分布式系统相关技术（如RPC、分布式锁等）

公告