``` AddSubscriber ```c++ 写一个消息订阅器class，AddSubscriber根据消息类型type绑定对应函数std::function，再有内部的线程对消息type进行分发到对应的函数,init的时候启动线程，

在C++中，我们可以创建一个名为`MessageSubscriber`的消息订阅者类，它允许用户注册不同类型的事件处理器并由内部线程负责在接收到相应类型的消息时执行这些处理器。以下是一个简化的实现示例：

#include <iostream>
#include <thread>
#include <map>
#include <mutex>
#include <condition_variable>

// 定义消息类型
enum class MessageType { TYPE_1, TYPE_2, TYPE_3 };

// 假设我们有一些处理函数模板，每个类型都有一个对应的处理函数
template <MessageType T>
void handle_message() {
    std::cout << "Handling message of type " << static_cast<int>(T) << std::endl;
}

class MessageSubscriber {
private:
    // 存储消息处理器和其对应的消息类型
    std::map<MessageType, std::function<void()>> handlers;
    std::thread dispatch_thread; // 发送线程
    mutable std::mutex mutex;
    std::condition_variable cond;

    // 添加处理器的方法
    void add_handler(MessageType type, std::function<void()> handler) {
        std::unique_lock<std::mutex> lock(mutex);
        handlers[type] = handler;
        if (dispatch_thread.joinable()) {
            lock.unlock();
            cond.notify_one(); // 唤醒等待的线程
        }
    }

public:
    // 初始化方法，启动发送线程
    explicit MessageSubscriber()
    : dispatch_thread([this]() {
        while (true) {
            std::unique_lock<std::mutex> lock(mutex);
            cond.wait(lock, [this] { return !handlers.empty(); });

            for (const auto& [type, handler] : handlers) {
                handler(); // 执行处理器
                handlers.erase(type); // 一旦处理器执行完毕，移除对应类型
            }
        }
    }) {}

    // 注册处理器
    template <MessageType T>
    void subscribe(std::function<void()> handler) {
        add_handler(T, handler);
    }

    // 示例用法
    void unsubscribe(MessageType type) {
        std::lock_guard<std::mutex> lock(mutex);
        handlers.erase(type);
    }

    // 用户可以在外部调用此函数发送不同类型的消息
    void publish(MessageType type) {
        add_handler(type, []() { handle_message<type>(); });
    }
};

int main() {
    MessageSubscriber subscriber;
    
    // 注册处理器
    subscriber.subscribe(MessageType::TYPE_1, &handle_message<MessageType::TYPE_1>);
    subscriber.subscribe(MessageType::TYPE_2, &handle_message<MessageType::TYPE_2>);
    
    // 发布消息
    subscriber.publish(MessageType::TYPE_1);
    subscriber.publish(MessageType::TYPE_2);

    // 在这里添加其他逻辑，比如注销处理器或接收更多消息

    return 0;
}

在这个例子中，`MessageSubscriber` 类维护了一个`std::map`来存储处理器和它们关联的消息类型。当`publish`方法被调用时，会将新的处理器添加到队列中，并唤醒等待的线程执行。线程会循环检查处理器队列，找到可执行的处理器并调用它们。