使用c++ RCF-2200源码要求实现 一个服务端多个客户端服务端下发任务时不给正在执行任务客户端下发任务给出实现源码

以下是使用C++编写的一个基于RCF-2.2.0.0的多线程服务端和多个客户端的实现示例：

服务端源码（server.cpp）：

#include <iostream>
#include <vector>
#include <string>
#include <RCF/RCF.hpp>

// 定义任务类
class Task
{
public:
    Task(int id, const std::string& desc) : m_id(id), m_desc(desc) {}

    int getId() const { return m_id; }
    std::string getDescription() const { return m_desc; }

private:
    int m_id;
    std::string m_desc;
};

// 定义服务接口
RCF_BEGIN(IJobService, "IJobService")
    RCF_METHOD_R1(std::vector<Task>, getTasks, int)
    RCF_METHOD_V1(void, submitResult, const Task&)
RCF_END(IJobService)

// 实现服务接口
class JobServiceImpl : public IJobService
{
public:
    std::vector<Task> getTasks(int clientId)
    {
        std::vector<Task> tasks;
        for (const auto& task : m_tasks)
        {
            if (task.getId() != m_currentTaskId)
            {
                tasks.push_back(task);
            }
        }
        
        return tasks;
    }

    void submitResult(const Task& task)
    {
        std::cout << "Received result for task #" << task.getId() << std::endl;
    }

    void addTask(const Task& task)
    {
        m_tasks.push_back(task);
    }

    void setCurrentTaskId(int taskId)
    {
        m_currentTaskId = taskId;
    }

private:
    int m_currentTaskId = -1;
    std::vector<Task> m_tasks;
};

int main()
{
    // 初始化 RCF
    RCF::RcfInitDeinit rcfInit;

    // 创建并启动服务
    RCF::RcfServer server(RCF::TcpEndpoint(50001));
    JobServiceImpl jobService;
    server.bind<IJobService>(jobService);
    server.start();

    std::cout << "Server started. Listening on port 50001." << std::endl;

    // 向服务添加一些任务
    jobService.addTask(Task(1, "Task 1"));
    jobService.addTask(Task(2, "Task 2"));
    jobService.addTask(Task(3, "Task 3"));

    // 模拟下发任务
    int taskId = 1;
    while (true)
    {
        std::this_thread::sleep_for(std::chrono::seconds(5));
        jobService.setCurrentTaskId(taskId);

        std::cout << "Task #" << taskId << " has been assigned." << std::endl;

        ++taskId;
        if (taskId > 3)
        {
            taskId = 1;
        }
    }

    // 停止服务
    server.stop();

    return 0;
}

客户端源码（client.cpp）：

#include <iostream>
#include <RCF/RCF.hpp>

// 定义任务类
class Task
{
public:
    Task(int id, const std::string& desc) : m_id(id), m_desc(desc) {}

    int getId() const { return m_id; }
    std::string getDescription() const { return m_desc; }

private:
    int m_id;
    std::string m_desc;
};

RCF_BEGIN(IJobService, "IJobService")
    RCF_METHOD_R1(std::vector<Task>, getTasks, int)
    RCF_METHOD_V1(void, submitResult, const Task&)
RCF_END(IJobService)

int main()
{
    // 初始化 RCF
    RCF::RcfInitDeinit rcfInit;

    // 创建客户端
    RCF::RcfClient<IJobService> client(RCF::TcpEndpoint("localhost", 50001));

    // 模拟多个客户端
    for (int clientId = 1; clientId <= 3; ++clientId)
    {
        std::cout << "Client #" << clientId << " started." << std::endl;

        // 客户端循环执行任务
        while (true)
        {
            std::vector<Task> tasks = client.getTasks(clientId);
            if (!tasks.empty())
            {
                Task task = tasks[0];
                std::cout << "Client #" << clientId << " received task #" << task.getId() << ": " << task.getDescription() << std::endl;

                // 模拟执行任务
                std::this_thread::sleep_for(std::chrono::seconds(10));

                // 提交任务结果
                client.submitResult(task);
            }
            else
            {
                std::cout << "Client #" << clientId << " is waiting for tasks." << std::endl;
                std::this_thread::sleep_for(std::chrono::seconds(5));
            }
        }
    }

    return 0;
}

编译和运行：

1. 使用C++编译器编译服务端代码：g++ -std=c++11 -I/path/to/RCF-2.2.0.0/include server.cpp -o server -lRCF
2. 使用C++编译器编译客户端代码：g++ -std=c++11 -I/path/to/RCF-2.2.0.0/include client.cpp -o client -lRCF
3. 分别在不同的终端窗口运行服务端和多个客户端：
   • 服务端：./server
   • 客户端1：./client
   • 客户端2：./client
   • 客户端3：./client

注意：请将/path/to/RCF-2.2.0.0/include替换为RCF-2.2.0.0源码的实际路径