C++如何实现一个Actor模型_利用C++构建高并发的Actor并发模型

Actor 模型通过独立实体间的消息传递实现并发，每个 Actor 拥有私有状态、邮箱和行为逻辑，C++ 中可利用 std::thread 与线程安全队列模拟，如 CounterActor 示例所示，通过消息触发状态变更，避免共享内存，确保线程安全，虽无原生支持但能高效构建高并发系统。

Actor 模型是一种处理并发计算的数学模型，每个 Actor 是独立的实体，通过消息传递进行通信，不共享状态。在 C ++ 中实现 Actor 模型，虽然不像 Erlang 或 Akka 那样原生支持，但借助现代 C ++（C++11 及以上）的多线程和异步机制，完全可以构建出高效、安全的高并发 Actor 系统。

Actor 模型核心思想

每个 Actor 拥有：

• 独立的状态：不与其他 Actor 共享内存
• 邮箱（Mailbox）：接收其他 Actor 发送的消息
• 行为逻辑：处理消息时执行的函数
• 创建与通信能力：可创建新 Actor，并向其他 Actor 发送消息

消息通过异步方式发送，Actor 逐个处理邮箱中的消息，避免竞态条件。

使用 std::thread 与消息队列实现 Actor

最基础的方式是为每个 Actor 分配一个线程或共享线程池，配合线程安全的消息队列。

立即学习“C++ 免费学习笔记（深入）”；

// 简单的消息基类

#include
#include
#include
#include #include
#include

struct Message {
    virtual ~Message() = default;
};

// 线程安全的消息队列
template
class ThreadSafeQueue {
private:
    mutable std::mutex mtx;
    std::queue data_queue;
public:
    void push(T msg) {
        std::lock_guard<:mutex> lock(mtx);
        data_queue.push(std::move(msg));
    }
    bool try_pop(T& value) {
        std::lock_guard<:mutex> lock(mtx);
        if (data_queue.empty()) return false;
        value = std::move(data_queue.front());
        data_queue.pop();
        return true;
    }
    bool empty() const {
        std::lock_guard<:mutex> lock(mtx);
        return data_queue.empty();
    }
};

定义 Actor 基类与行为

Actor 运行在一个独立的上下文中，循环从邮箱取消息并处理。

class Actor {
public:
    using MessagePtr = std::shared_ptr;
    virtual ~Actor() { stop(); }

    void start() {
        running = true;
        thread = std::thread([this] {run(); });
    }

    void stop() {
        running = false;
        if (thread.joinable()) thread.join();
    }

    void send(MessagePtr msg) {
        mailbox.push(std::move(msg));
    }

protected:
    virtual void onMessage(const MessagePtr& msg) = 0;

private:
    void run() {
        while (running) {
            MessagePtr msg;
            if (mailbox.try_pop(msg)) {
                if (msg) onMessage(msg);
            } else {
                std::this_thread::sleep_for(std::chrono::nanoseconds(10));
            }
        }
    }

    ThreadSafeQueue mailbox;
    std::thread thread;
    std::atomic running{false};
};

实现具体 Actor 示例

比如一个计数 Actor，接收增加指令并打印当前值。

struct IncrementMsg : Message {
    int delta;
    IncrementMsg(int d) : delta(d) {}
};

class CounterActor : public Actor {
private:
    int count = 0;

protected:
    void onMessage(const MessagePtr& msg) override {
        if (auto inc = dynamic_cast(msg.get())) {
            count += inc->delta;
            printf(“Count is now: %dn”, count);
        }
    }
};

int main() {
    CounterActor counter;
    counter.start();

    counter.send(std::make_shared(1));
    counter.send(std::make_shared(2));
    counter.send(std::make_shared(3));

    std::this_thread::sleep_for(std::chrono::seconds(1)); // 等待处理
    return 0;
}

基本上就这些。这个简单框架展示了 Actor 模型的核心：封装状态、消息驱动、异步通信。实际生产中可进一步优化，如使用 无锁 队列、Actor 池、调度器分离等。C++ 虽无原生 Actor 支持，但凭借其灵活性和性能优势，完全能构建出媲美 Erlang 的高并发 Actor 系统。