c++实现线程池，以红黑树作为消息队列按优先级排序

线程池是一种常见的多线程并发编程模型，可以有效地利用多核 CPU 的资源，提高程序的并发能力和运行效率。红黑树是一种高效的自平衡二叉查找树，可以用来实现消息队列，按照优先级排序。

下面是一个简单的 C++ 实现线程池，以红黑树作为消息队列按优先级排序的示例代码：

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <functional>
#include <map>

// 定义任务类
class Task {
public:
    Task(std::function<void()> f, int p) : func(f), priority(p) {}
    void operator()() const { func(); }
    int getPriority() const { return priority; }
private:
    std::function<void()> func;
    int priority;
};

// 定义比较函数
struct TaskCompare {
    bool operator() (const Task& t1, const Task& t2) const {
        return t1.getPriority() < t2.getPriority();
    }
};

// 定义线程池类
class ThreadPool {
public:
    ThreadPool(int num_threads) : stop(false) {
        for (int i = 0; i < num_threads; ++i) {
            threads.emplace_back(std::bind(&ThreadPool::threadFunc, this));
        }
    }
    ~ThreadPool() {
        {
            std::unique_lock<std::mutex> lock(mutex_);
            stop = true;
        }
        condition_.notify_all();
        for (std::thread& t : threads) {
            t.join();
        }
    }
    template<class F>
    void addTask(F&& f, int priority) {
        {
            std::unique_lock<std::mutex> lock(mutex_);
            tasks.emplace(Task(std::forward<F>(f), priority));
        }
        condition_.notify_one();
    }
private:
    void threadFunc() {
        while (true) {
            std::unique_lock<std::mutex> lock(mutex_);
            condition_.wait(lock, [this]{ return !tasks.empty() || stop; });
            if (stop && tasks.empty()) {
                return;
            }
            Task task = tasks.top();
            tasks.pop();
            lock.unlock();
            task();
        }
    }
    std::priority_queue<Task, std::vector<Task>, TaskCompare> tasks;
    std::vector<std::thread> threads;
    std::mutex mutex_;
    std::condition_variable condition_;
    bool stop;
};

int main() {
    // 创建线程池
    ThreadPool pool(4);
    // 添加任务
    pool.addTask([]{ std::cout << "Task 1 (priority 1) running...\n"; }, 1);
    pool.addTask([]{ std::cout << "Task 2 (priority 3) running...\n"; }, 3);
    pool.addTask([]{ std::cout << "Task 3 (priority 2) running...\n"; }, 2);
    pool.addTask([]{ std::cout << "Task 4 (priority 4) running...\n"; }, 4);
    // 等待任务完成
    std::this_thread::sleep_for(std::chrono::seconds(1));
    return 0;
}

在上面的代码中，我们定义了一个 `Task` 类来表示任务，包括一个函数指针和一个优先级。我们还定义了一个比较函数 `TaskCompare`，用于比较两个任务的优先级大小。

线程池类中包含一个优先队列 `tasks`，用于存储任务，按照优先级从高到低排序。我们使用一个 `std::mutex` 来保护队列的并发访问，并使用一个 `std::condition_variable` 来实现线程间的同步和通信。

在线程池的构造函数中，我们创建了指定数量的线程，并将它们的执行函数绑定到 `ThreadPool::threadFunc` 函数上。在 `ThreadPool::addTask` 函数中，我们向队列中添加一个新任务，并通知一个等待中的线程。

执行线程的主函数是 `ThreadPool::threadFunc`，它在一个无限循环中等待任务的到来。当队列中有任务时，它会取出队列中优先级最高的任务并执行。如果队列为空且线程池已经停止，则线程退出循环。

在 `main` 函数中，我们创建了一个线程池，并向它添加了四个任务，分别具有不同的优先级。我们使用 `std::this_thread::sleep_for` 函数等待所有任务完成后程序退出。

以上就是一个简单的 C++ 实现线程池，以红黑树作为消息队列按优先级排序的示例代码。