C++ RCF-2.2.0.0 源码：实现多客户端并发计算任务

本示例展示了使用 C++ 和 RCF-2.2.0.0 库实现一个简单的多客户端并发计算任务系统。服务端负责下发任务给客户端，客户端接收任务并进行大量运算工作，确保同一时间只有一个客户端执行任务。

服务端源码

#include <iostream>
#include <string>
#include <vector>
#include <thread>
#include <mutex>
#include <condition_variable>

// 定义任务结构体
struct Task {
    int id;
    std::string data;
};

// 定义服务端类
class Server {
public:
    Server() : currentClientId(0) {}

    void start() {
        // 创建客户端线程
        std::vector<std::thread> clientThreads;
        for (int i = 0; i < numClients; ++i) {
            clientThreads.emplace_back(std::thread(&Server::clientThreadFunc, this, i));
        }

        // 启动服务端线程
        serverThread = std::thread(&Server::serverThreadFunc, this);

        // 等待客户端线程结束
        for (int i = 0; i < numClients; ++i) {
            clientThreads[i].join();
        }

        // 等待服务端线程结束
        serverThread.join();
    }

private:
    static const int numClients = 5;  // 客户端数量
    std::mutex mtx;  // 互斥锁
    std::condition_variable cv;  // 条件变量
    int currentClientId;  // 当前客户端ID
    std::thread serverThread;  // 服务端线程

    // 服务端线程函数
    void serverThreadFunc() {
        for (int i = 0; i < 10; ++i) {  // 下发10个任务
            // 创建任务
            Task task;
            task.id = i;
            task.data = 'Task ' + std::to_string(i);

            // 等待客户端完成上一个任务
            std::unique_lock<std::mutex> lock(mtx);
            cv.wait(lock, [this]() { return currentClientId == numClients; });

            // 下发任务给客户端
            currentClientId = 0;
            std::cout << 'Sending task ' << task.id << ' to client ' << currentClientId << std::endl;
            cv.notify_all();
        }
    }

    // 客户端线程函数
    void clientThreadFunc(int clientId) {
        for (;;) {
            // 接收任务
            std::unique_lock<std::mutex> lock(mtx);
            cv.wait(lock, [this, clientId]() { return currentClientId == clientId; });

            // 完成任务
            std::cout << 'Client ' << clientId << ' is processing task' << std::endl;

            // 模拟耗时运算
            std::string result;
            for (int i = 0; i < 10000000; ++i) {
                result += 'c++';
            }

            // 输出结果
            std::cout << 'Client ' << clientId << ' finished task' << std::endl;

            // 切换到下一个任务
            ++currentClientId;
            cv.notify_all();
        }
    }
};

int main() {
    Server server;
    server.start();
    return 0;
}

代码说明

任务结构体 (Task)：定义了任务的 ID 和数据，用于传递任务信息。
服务端类 (Server)：
- start() 函数：启动服务端线程和客户端线程，并等待所有线程结束。
- serverThreadFunc() 函数：负责创建任务并下发给客户端。使用 mtx 和 cv 确保每次只有一个客户端执行任务。
- clientThreadFunc() 函数：负责接收任务并执行运算。使用 mtx 和 cv 等待服务端下发任务。

关键实现细节

使用 std::mutex 和 std::condition_variable 实现线程同步，保证一次只有一个客户端执行任务。
服务端在每次下发任务前，使用 cv.wait() 等待所有客户端完成上一个任务。
客户端在接收任务前，使用 cv.wait() 等待服务端下发任务。

注意

本示例仅展示了基本的实现方式，实际应用中需要考虑更多细节，例如：

客户端异常退出时的处理
任务分配策略
任务结果收集
错误处理和日志记录

使用 RCF-2.2.0.0

RCF 库可以用于构建更复杂的任务分配和通信机制，例如：

使用 RCF 的远程过程调用 (RPC) 实现服务端和客户端之间的通信。
使用 RCF 的对象序列化机制传递复杂的任务数据。

RCF 的使用可以使系统更加灵活和可扩展。

总结

本示例演示了如何使用 C++ 和线程同步机制实现一个简单的多客户端并发计算任务系统。通过使用 RCF 库，可以进一步扩展系统功能，实现更复杂的分布式计算任务。