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分配一个线程或共享线程池，配合线程安全的消息队列。

// 简单的消息基类

#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: %d\n", 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系统。

# c++ # ai # 邮箱 # 无锁 # red # erlang # if # count # while # 封装 # include # printf # const # auto # bool # int # void # mutable # 循环 # using # class # public # private # protected # Struct # 线程 # 多线程 # Thread # 并发 # default # this # 异步 # 虽无 # 是一种 # 不像 # 所示 # 并向 # 不与 # 可利用 # 但能 # 发送消息

返回目录在线咨询

上一篇：关于redis Key淘汰策略的实现方法
下一篇：如何在ZPanel中备份和恢复网站数据？

您的项目需求