如何在C++线程类中实现任务分配-乐工具技术知识

在 C++ 中，可以使用` 库来创建线程并分配任务

#include
#include
#include
#include 

class Task {
public:
    virtual void execute() = 0;
};

class PrintTask : public Task {
public:
    PrintTask(const std::string& message) : message_(message) {}

    void execute() override {
        std::cout << "Thread "<< std::this_thread::get_id() << ": "<< message_<< std::endl;
    }

private:
    std::string message_;
};

class ThreadPool {
public:
    ThreadPool(size_t num_threads) {
        for (size_t i = 0; i < num_threads; ++i) {
            threads_.emplace_back(&ThreadPool::worker, this);
        }
    }

    ~ThreadPool() {
        {
            std::unique_lock lock(queue_mutex_);
            stop_ = true;
        }
        condition_.notify_all();
        for (auto& thread : threads_) {
            thread.join();
        }
    }

    void add_task(Task* task) {
        std::unique_lock lock(queue_mutex_);
        tasks_.push(task);
        condition_.notify_one();
    }

private:
    void worker() {
        while (true) {
            Task* task = nullptr;
            {
                std::unique_lock lock(queue_mutex_);
                condition_.wait(lock, [this] { return !tasks_.empty() || stop_; });
                if (stop_) {
                    break;
                }
                task = tasks_.front();
                tasks_.pop();
            }
            task->execute();
        }
    }

    std::vector threads_;
    std::queue tasks_;
    std::mutex queue_mutex_;
    std::condition_variable condition_;
    bool stop_ = false;
};

int main() {
    ThreadPool pool(4); // 创建一个包含 4 个线程的线程池

    // 添加任务到线程池
    for (int i = 0; i < 10; ++i) {
        pool.add_task(new PrintTask("Hello from task " + std::to_string(i)));
    }

    // 等待所有任务完成
    // 注意：这里没有删除任务对象，实际应用中需要考虑内存管理
    std::this_thread::sleep_for(std::chrono::seconds(2));

    return 0;
}

这个示例中，我们定义了一个 Task 基类和一个派生自 Task 的 PrintTask 类。ThreadPool 类负责管理线程和任务队列。add_task 方法用于向线程池添加新任务。线程池中的每个线程都会从任务队列中获取任务并执行它。

请注意，这个示例没有处理任务对象的内存管理。在实际应用中，你需要考虑如何安全地删除任务对象以避免内存泄漏。可以考虑使用智能指针（如 std::shared_ptr 或 std::unique_ptr）来管理任务对象的生命周期。