C++中的Actor模型是一種并發(fā)編程模型，它通過(guò)將計(jì)算單元封裝為獨(dú)立、可并發(fā)執(zhí)行的Actor實(shí)例，來(lái)實(shí)現(xiàn)并發(fā)和消息傳遞。每個(gè)Actor都有自己的狀態(tài)和行為，并且通過(guò)接收和發(fā)送消息來(lái)進(jìn)行通信。Actor之間是完全隔離的，它們之間只能通過(guò)消息進(jìn)行通信，從而避免了共享狀態(tài)和顯式鎖的問(wèn)題。

下面是一個(gè)簡(jiǎn)單的C++ Actor模型的示例實(shí)現(xiàn)：

#include <IOStream>
#include <queue>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>

class Actor {
public:
    void run() {
        while (!stop) {
            std::function<void()> message;

            {
                std::unique_lock<std::mutex> lock(mutex);

                condition.wAIt(lock, [this]() {
                    return stop || !messageQueue.empty();
                });

                if (stop && messageQueue.empty()) {
                    return;
                }

                message = std::move(messageQueue.front());
                messageQueue.pop();
            }

            message();
        }
    }

    template<typename F, typename... Args>
    void send(F&& f, Args&&... args) {
        {
            std::lock_guard<std::mutex> lock(mutex);
            messageQueue.emplace(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        }

        condition.notify_one();
    }

    void stopActor() {
        {
            std::lock_guard<std::mutex> lock(mutex);
            stop = true;
        }

        condition.notify_all();
    }

private:
    std::queue<std::function<void()>> messageQueue;
    std::mutex mutex;
    std::condition_variable condition;
    bool stop = false;
};

// 示例Actor行為
class MyActor {
public:
    void doSomething(int id) {
        std::cout << "Actor ID: " << id << ", thread ID: " << std::this_thread::get_id() << std::endl;
        // 具體行為邏輯
    }
};

int main() {
    MyActor actor;

    Actor actingThread;

    actingThread.send([&actor]() {
        actor.doSomething(1);
    });

    actingThread.send([&actor]() {
        actor.doSomething(2);
    });

    actingThread.send([&actingThread]() {
        actingThread.stopActor();
    });

    std::thread thread([&actingThread]() {
        actingThread.run();
    });

    thread.join();

    return 0;
}

上述代碼實(shí)現(xiàn)了一個(gè)簡(jiǎn)單的Actor模型。在Actor類中，使用條件變量和互斥鎖來(lái)實(shí)現(xiàn)Actor的同步和通信。每個(gè)Actor都維護(hù)一個(gè)消息隊(duì)列，通過(guò)send方法向隊(duì)列中添加消息。

在main函數(shù)中，示例代碼創(chuàng)建了一個(gè)MyActor對(duì)象并實(shí)例化了一個(gè)Actor對(duì)象。通過(guò)調(diào)用Actor對(duì)象的send方法，將消息發(fā)送給MyActor對(duì)象。MyActor對(duì)象中的doSomething方法會(huì)在調(diào)用線程的上下文中執(zhí)行。

然后，通過(guò)調(diào)用stopActor方法停止Actor線程。最后，創(chuàng)建一個(gè)新線程運(yùn)行Actor的run方法來(lái)處理消息隊(duì)列中的消息。

請(qǐng)注意，上述示例代碼只是一個(gè)簡(jiǎn)單的Actor模型的實(shí)現(xiàn)，實(shí)際使用時(shí)可能需要考慮更多的細(xì)節(jié)，如Actor之間的連接、創(chuàng)建多個(gè)Actor對(duì)象、消息路由等。Actor模型可以作為實(shí)現(xiàn)并發(fā)和并行的一種有趣和強(qiáng)大的方式，它可以提供更好的抽象和隔離性來(lái)處理并發(fā)編程中的問(wèn)題。

添加actor之間的連接功能

要實(shí)現(xiàn)Actor之間的連接功能，可以使用一個(gè)中央調(diào)度器來(lái)管理Actor之間的消息傳遞和通信。下面是一個(gè)示例的C++ Actor模型的實(shí)現(xiàn)，包括Actor之間的連接功能：

#include <iostream>
#include <queue>
#include <thread>
#include <functional>
#include <mutex>
#include <condition_variable>
#include <unordered_map>

class Actor {
public:
    void run() {
        while (!stop) {
            std::function<void()> message;

            {
                std::unique_lock<std::mutex> lock(mutex);

                condition.wait(lock, [this]() {
                    return stop || !messageQueue.empty();
                });

                if (stop && messageQueue.empty()) {
                    return;
                }

                message = std::move(messageQueue.front());
                messageQueue.pop();
            }

            message();
        }
    }

    template<typename F, typename... Args>
    void send(F&& f, Args&&... args) {
        {
            std::lock_guard<std::mutex> lock(mutex);
            messageQueue.emplace(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
        }

        condition.notify_one();
    }

    void stopActor() {
        {
            std::lock_guard<std::mutex> lock(mutex);
            stop = true;
        }

        condition.notify_all();
    }

private:
    std::queue<std::function<void()>> messageQueue;
    std::mutex mutex;
    std::condition_variable condition;
    bool stop = false;
};

class ActorSystem {
public:
    ActorSystem() {
        std::thread thread([this]() {
            this->run();
        });
        thread.detach();
    }

    template<typename T>
    Actor& createActor() {
        std::unique_lock<std::mutex> lock(mutex);

        Actor* actor = new Actor();
        actors.emplace(actorId, actor);
        actorId++;

        return *actor;
    }

    void sendMessage(int actorId, std::function<void()> message) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors[actorId]->send(message);
        }
    }

    void stopActor(int actorId) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors[actorId]->stopActor();
            delete actors[actorId];
            actors.erase(actorId);
        }
    }

private:
    void run() {
        while (true) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

            std::unique_lock<std::mutex> lock(mutex);

            for (const auto& actor : actors) {
                actor.second->run();
            }
        }
    }

    std::unordered_map<int, Actor*> actors;
    int actorId = 0;
    std::mutex mutex;
};

// 示例Actor行為
class MyActor {
public:
    MyActor(ActorSystem& actorSystem) : actorSystem(actorSystem) {}

    void doSomething(int id) {
        std::cout << "Actor ID: " << id << ", thread ID: " << std::this_thread::get_id() << std::endl;
        // 具體行為邏輯

        // 發(fā)送消息給其他Actor
        actorSystem.sendMessage(1, [this]() {
            this->doSomethingElse();
        });
    }

    void doSomethingElse() {
        std::cout << "Doing something else" << std::endl;
        // 具體行為邏輯
    }

private:
    ActorSystem& actorSystem;
};

int main() {
    ActorSystem actorSystem;

    MyActor actor1(actorSystem);
    MyActor actor2(actorSystem);

    Actor& actor1Ref = actorSystem.createActor<MyActor>();
    Actor& actor2Ref = actorSystem.createActor<MyActor>();

    actor1Ref.send([&actor1]() {
        actor1.doSomething(1);
    });

    actor2Ref.send([&actor2]() {
        actor2.doSomething(2);
    });

    std::this_thread::sleep_for(std::chrono::seconds(5));

    actorSystem.stopActor(0);
    actorSystem.stopActor(1);

    return 0;
}

上述代碼中，我們引入了一個(gè)ActorSystem類來(lái)管理所有的Actor。ActorSystem類中維護(hù)了一個(gè)unordered_map來(lái)存儲(chǔ)Actor的ID和指針的映射關(guān)系。createActor方法用于創(chuàng)建新的Actor，并返回其引用。sendMessage方法用于向指定的Actor發(fā)送消息，stopActor方法用于停止指定的Actor。

在MyActor類中，我們添加了一個(gè)doSomethingElse方法，用于演示如何向其他Actor發(fā)送消息。在doSomething方法中，我們通過(guò)actorSystem.sendMessage方法向ID為1的Actor發(fā)送消息。

在main函數(shù)中，我們創(chuàng)建了兩個(gè)MyActor對(duì)象，并通過(guò)createActor方法創(chuàng)建了兩個(gè)對(duì)應(yīng)的Actor。然后，我們通過(guò)調(diào)用send方法向兩個(gè)Actor發(fā)送消息。最后，我們通過(guò)調(diào)用stopActor方法停止兩個(gè)Actor。

請(qǐng)注意，上述示例代碼只是一個(gè)簡(jiǎn)單的Actor模型的實(shí)現(xiàn)，實(shí)際使用時(shí)可能需要考慮更多的細(xì)節(jié)，如消息路由、Actor之間的連接關(guān)系、消息隊(duì)列的優(yōu)化等。Actor模型是一種強(qiáng)大的并發(fā)編程模型，可以提供更好的抽象和隔離性來(lái)處理并發(fā)編程中的問(wèn)題。

再添加消息路由功能

要添加消息路由功能，我們可以為ActorSystem類添加一個(gè)Router類成員變量，并在sendMessage方法中使用路由器來(lái)選擇目標(biāo)Actor。下面是更新后的代碼：

class Router {
public:
    virtual int route(const std::unordered_map<int, Actor*>& actors) = 0;
};

class RoundRobinRouter : public Router {
public:
    int route(const std::unordered_map<int, Actor*>& actors) override {
        if (actors.empty()) {
            return -1;
        }

        currentActorIndex = (currentActorIndex + 1) % actors.size();
        auto it = std::next(actors.begin(), currentActorIndex);
        return it->first;
    }

private:
    int currentActorIndex = -1;
};

class ActorSystem {
public:
    ActorSystem() {
        std::thread thread([this]() {
            this->run();
        });
        thread.detach();
    }

    template<typename T>
    Actor& createActor() {
        std::unique_lock<std::mutex> lock(mutex);

        Actor* actor = new Actor();
        actors.emplace(actorId, actor);
        actorId++;

        return *actor;
    }

    void sendMessage(std::function<void()> message, Router* router = nullptr) {
        std::unique_lock<std::mutex> lock(mutex);

        int actorId = -1;

        if (router != nullptr) {
            actorId = router->route(actors);
        } else {
            if (!actors.empty()) {
                actorId = actors.begin()->first;
            }
        }

        if (actorId != -1) {
            actors[actorId]->send(message);
        }
    }

    void stopActor(int actorId) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors[actorId]->stopActor();
            delete actors[actorId];
            actors.erase(actorId);
        }
    }

private:
    void run() {
        while (true) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

            std::unique_lock<std::mutex> lock(mutex);

            for (const auto& actor : actors) {
                actor.second->run();
            }
        }
    }

    std::unordered_map<int, Actor*> actors;
    int actorId = 0;
    std::mutex mutex;
};

在上述代碼中，我們添加了一個(gè)Router類和一個(gè)具體的RoundRobinRouter類。Router類是一個(gè)抽象類，其中定義了一個(gè)route方法，用于根據(jù)一組Actor選擇目標(biāo)Actor。RoundRobinRouter類是一個(gè)具體的路由器實(shí)現(xiàn)，它使用輪詢的方式選擇目標(biāo)Actor。

在ActorSystem類中，我們添加了一個(gè)可選的路由器參數(shù)router，并在sendMessage方法中使用路由器來(lái)選擇目標(biāo)Actor。如果沒(méi)有指定路由器，則默認(rèn)選擇第一個(gè)Actor。

你可以根據(jù)需要實(shí)現(xiàn)其他的路由器策略，比如隨機(jī)選擇、基于消息負(fù)載的選擇等。

使用示例代碼：

int main() {
    ActorSystem actorSystem;

    MyActor actor1(actorSystem);
    MyActor actor2(actorSystem);

    Actor& actor1Ref = actorSystem.createActor<MyActor>();
    Actor& actor2Ref = actorSystem.createActor<MyActor>();

    RoundRobinRouter router;

    actorSystem.sendMessage([&actor1]() {
        actor1.doSomething(1);
    }, &router);

    actorSystem.sendMessage([&actor2]() {
        actor2.doSomething(2);
    }, &router);

    std::this_thread::sleep_for(std::chrono::seconds(5));

    actorSystem.stopActor(0);
    actorSystem.stopActor(1);

    return 0;
}

在上述示例代碼中，我們創(chuàng)建了一個(gè)RoundRobinRouter對(duì)象，并將其作為參數(shù)傳遞給sendMessage方法。這樣，消息將根據(jù)輪詢策略路由到不同的Actor上。

請(qǐng)注意，上述示例代碼僅僅是一個(gè)簡(jiǎn)單的消息路由實(shí)現(xiàn)，實(shí)際使用時(shí)可能需要考慮更多的細(xì)節(jié)，比如路由策略的靈活性、動(dòng)態(tài)添加/刪除Actor時(shí)的路由更新等。

進(jìn)一步優(yōu)化路由策略的靈活性

要優(yōu)化路由策略的靈活性，我們可以將路由策略從Router類中分離出來(lái)，并使用策略模式來(lái)實(shí)現(xiàn)。下面是更新后的代碼：

class RoutingStrategy {
public:
    virtual int selectActor(const std::unordered_map<int, Actor*>& actors) = 0;
};

class Router {
public:
    Router(RoutingStrategy* strategy) : strategy(strategy) {}

    int route(const std::unordered_map<int, Actor*>& actors) {
        return strategy->selectActor(actors);
    }

private:
    RoutingStrategy* strategy;
};

class RoundRobinStrategy : public RoutingStrategy {
public:
    int selectActor(const std::unordered_map<int, Actor*>& actors) override {
        if (actors.empty()) {
            return -1;
        }

        currentActorIndex = (currentActorIndex + 1) % actors.size();
        auto it = std::next(actors.begin(), currentActorIndex);
        return it->first;
    }

private:
    int currentActorIndex = -1;
};

class RandomStrategy : public RoutingStrategy {
public:
    int selectActor(const std::unordered_map<int, Actor*>& actors) override {
        if (actors.empty()) {
            return -1;
        }

        std::random_device rd;
        std::mt19937 gen(rd());
        std::uniform_int_distribution<> dis(0, actors.size() - 1);

        auto it = std::next(actors.begin(), dis(gen));
        return it->first;
    }
};

class ActorSystem {
public:
    ActorSystem() {
        std::thread thread([this]() {
            this->run();
        });
        thread.detach();
    }

    template<typename T>
    Actor& createActor() {
        std::unique_lock<std::mutex> lock(mutex);

        Actor* actor = new Actor();
        actors.emplace(actorId, actor);
        actorId++;

        return *actor;
    }

    void sendMessage(std::function<void()> message, RoutingStrategy* strategy = nullptr) {
        std::unique_lock<std::mutex> lock(mutex);

        int actorId = -1;

        if (strategy != nullptr) {
            actorId = strategy->selectActor(actors);
        } else {
            if (!actors.empty()) {
                actorId = actors.begin()->first;
            }
        }

        if (actorId != -1) {
            actors[actorId]->send(message);
        }
    }

    void stopActor(int actorId) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors[actorId]->stopActor();
            delete actors[actorId];
            actors.erase(actorId);
        }
    }

private:
    void run() {
        while (true) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

            std::unique_lock<std::mutex> lock(mutex);

            for (const auto& actor : actors) {
                actor.second->run();
            }
        }
    }

    std::unordered_map<int, Actor*> actors;
    int actorId = 0;
    std::mutex mutex;
};

在上述代碼中，我們將路由策略從Router類中分離出來(lái)，并定義了一個(gè)RoutingStrategy抽象類。RoutingStrategy類中定義了一個(gè)selectActor方法，用于根據(jù)一組Actor選擇目標(biāo)Actor。

然后，我們實(shí)現(xiàn)了兩個(gè)具體的路由策略類：RoundRobinStrategy和RandomStrategy。RoundRobinStrategy類使用輪詢的方式選擇目標(biāo)Actor，RandomStrategy類使用隨機(jī)選擇的方式選擇目標(biāo)Actor。

在Router類中，我們使用了策略模式，將具體的路由策略對(duì)象存儲(chǔ)在成員變量中，并在route方法中調(diào)用策略對(duì)象的selectActor方法。

在ActorSystem類中，我們添加了一個(gè)可選的策略參數(shù)strategy，并在sendMessage方法中使用策略對(duì)象來(lái)選擇目標(biāo)Actor。如果沒(méi)有指定策略對(duì)象，則默認(rèn)選擇第一個(gè)Actor。

使用示例代碼：

int main() {
    ActorSystem actorSystem;

    MyActor actor1(actorSystem);
    MyActor actor2(actorSystem);

    Actor& actor1Ref = actorSystem.createActor<MyActor>();
    Actor& actor2Ref = actorSystem.createActor<MyActor>();

    RoundRobinStrategy roundRobinStrategy;
    RandomStrategy randomStrategy;

    Router roundRobinRouter(&roundRobinStrategy);
    Router randomRouter(&randomStrategy);

    actorSystem.sendMessage([&actor1]() {
        actor1.doSomething(1);
    }, &roundRobinRouter);

    actorSystem.sendMessage([&actor2]() {
        actor2.doSomething(2);
    }, &randomRouter);

    std::this_thread::sleep_for(std::chrono::seconds(5));

    actorSystem.stopActor(0);
    actorSystem.stopActor(1);

    return 0;
}

在上述示例代碼中，我們創(chuàng)建了一個(gè)RoundRobinStrategy對(duì)象和一個(gè)RandomStrategy對(duì)象，并將它們分別傳遞給RoundRobinRouter和RandomRouter對(duì)象。這樣，消息將根據(jù)不同的策略路由到不同的Actor上。

通過(guò)使用策略模式，我們可以很容易地添加新的路由策略，只需實(shí)現(xiàn)一個(gè)新的策略類，并將其傳遞給Router對(duì)象即可。這樣，我們可以根據(jù)需要靈活地選擇不同的路由策略。

動(dòng)態(tài)添加/刪除Actor時(shí)的路由更新

當(dāng)動(dòng)態(tài)添加或刪除Actor時(shí)，需要更新路由策略，以確保新添加的Actor也能夠接收到消息。

對(duì)于動(dòng)態(tài)添加Actor，我們可以在ActorSystem類中添加一個(gè)addActor方法，用于向actors容器中添加新的Actor。在添加完Actor之后，我們需要更新路由策略對(duì)象中的Actor列表。

對(duì)于動(dòng)態(tài)刪除Actor，我們可以在ActorSystem類中添加一個(gè)removeActor方法，用于從actors容器中刪除指定的Actor。在刪除完Actor之后，我們同樣需要更新路由策略對(duì)象中的Actor列表。

下面是更新后的ActorSystem類的代碼：

class ActorSystem {
public:
    ActorSystem() {
        std::thread thread([this]() {
            this->run();
        });
        thread.detach();
    }

    template<typename T>
    Actor& createActor() {
        std::unique_lock<std::mutex> lock(mutex);

        Actor* actor = new Actor();
        actors.emplace(actorId, actor);
        actorId++;

        // Update routing strategy
        for (auto& strategy : routingStrategies) {
            strategy->updateActors(actors);
        }

        return *actor;
    }

    void addActor(int actorId, Actor* actor) {
        std::unique_lock<std::mutex> lock(mutex);

        actors.emplace(actorId, actor);

        // Update routing strategy
        for (auto& strategy : routingStrategies) {
            strategy->updateActors(actors);
        }
    }

    void removeActor(int actorId) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors.erase(actorId);

            // Update routing strategy
            for (auto& strategy : routingStrategies) {
                strategy->updateActors(actors);
            }
        }
    }

    void sendMessage(std::function<void()> message, RoutingStrategy* strategy = nullptr) {
        std::unique_lock<std::mutex> lock(mutex);

        int actorId = -1;

        if (strategy != nullptr) {
            actorId = strategy->selectActor(actors);
        } else {
            if (!actors.empty()) {
                actorId = actors.begin()->first;
            }
        }

        if (actorId != -1) {
            actors[actorId]->send(message);
        }
    }

    void stopActor(int actorId) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors[actorId]->stopActor();
            delete actors[actorId];
            actors.erase(actorId);
        }
    }

    void addRoutingStrategy(RoutingStrategy* strategy) {
        routingStrategies.push_back(strategy);
        strategy->updateActors(actors);
    }

private:
    void run() {
        while (true) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

            std::unique_lock<std::mutex> lock(mutex);

            for (const auto& actor : actors) {
                actor.second->run();
            }
        }
    }

    std::unordered_map<int, Actor*> actors;
    std::vector<RoutingStrategy*> routingStrategies;
    int actorId = 0;
    std::mutex mutex;
};

在更新后的ActorSystem類中，我們添加了一個(gè)routingStrategies成員變量，用于存儲(chǔ)所有的路由策略對(duì)象。在添加或刪除Actor時(shí)，我們需要遍歷routingStrategies并調(diào)用每個(gè)策略對(duì)象的updateActors方法，以更新Actor列表。

此外，我們還添加了一個(gè)addRoutingStrategy方法，用于向routingStrategies中添加新的路由策略對(duì)象。在添加完路由策略對(duì)象之后，我們同樣需要調(diào)用updateActors方法來(lái)更新Actor列表。

使用示例代碼：

int main() {
    ActorSystem actorSystem;

    MyActor actor1(actorSystem);
    MyActor actor2(actorSystem);

    Actor& actor1Ref = actorSystem.createActor<MyActor>();
    Actor& actor2Ref = actorSystem.createActor<MyActor>();

    RoundRobinStrategy roundRobinStrategy;
    RandomStrategy randomStrategy;

    actorSystem.addRoutingStrategy(&roundRobinStrategy);
    actorSystem.addRoutingStrategy(&randomStrategy);

    actorSystem.sendMessage([&actor1]() {
        actor1.doSomething(1);
    }, &roundRobinStrategy);

    actorSystem.sendMessage([&actor2]() {
        actor2.doSomething(2);
    }, &randomStrategy);

    std::this_thread::sleep_for(std::chrono::seconds(5));

    actorSystem.stopActor(0);
    actorSystem.stopActor(1);

    return 0;
}

在上述示例代碼中，我們首先創(chuàng)建了兩個(gè)MyActor對(duì)象，并將它們添加到ActorSystem中。然后，我們創(chuàng)建了一個(gè)RoundRobinStrategy對(duì)象和一個(gè)RandomStrategy對(duì)象，并將它們分別添加到ActorSystem中。

接下來(lái)，我們使用sendMessage方法向不同的路由策略發(fā)送消息。在發(fā)送消息之前，我們需要將路由策略對(duì)象傳遞給sendMessage方法。

最后，我們停止了兩個(gè)Actor，并結(jié)束了程序。在停止Actor之后，我們需要調(diào)用stopActor方法，并在ActorSystem中刪除相應(yīng)的Actor。

完整代碼

#include <iostream>
#include <thread>
#include <chrono>
#include <unordered_map>
#include <functional>
#include <mutex>

class Actor {
public:
    Actor() {}

    void send(std::function<void()> message) {
        messages.push_back(message);
    }

    void run() {
        std::unique_lock<std::mutex> lock(mutex);

        for (const auto& message : messages) {
            message();
        }

        messages.clear();
    }

    void stopActor() {
        std::unique_lock<std::mutex> lock(mutex);

        stopped = true;
    }

private:
    std::vector<std::function<void()>> messages;
    std::mutex mutex;
    bool stopped = false;
};

class RoutingStrategy {
public:
    virtual int selectActor(const std::unordered_map<int, Actor*>& actors) = 0;
    virtual void updateActors(const std::unordered_map<int, Actor*>& actors) = 0;
};

class RoundRobinStrategy : public RoutingStrategy {
public:
    int selectActor(const std::unordered_map<int, Actor*>& actors) override {
        if (actors.empty()) {
            return -1;
        }

        if (currentActor >= actors.size()) {
            currentActor = 0;
        }

        auto it = actors.begin();
        std::advance(it, currentActor);
        currentActor++;

        return it->first;
    }

    void updateActors(const std::unordered_map<int, Actor*>& actors) override {
        this->actors = actors;
    }

private:
    std::unordered_map<int, Actor*> actors;
    int currentActor = 0;
};

class RandomStrategy : public RoutingStrategy {
public:
    int selectActor(const std::unordered_map<int, Actor*>& actors) override {
        if (actors.empty()) {
            return -1;
        }

        int randomIndex = rand() % actors.size();
        auto it = actors.begin();
        std::advance(it, randomIndex);

        return it->first;
    }

    void updateActors(const std::unordered_map<int, Actor*>& actors) override {
        this->actors = actors;
    }

private:
    std::unordered_map<int, Actor*> actors;
};

class ActorSystem {
public:
    template<typename ActorType>
    ActorType& createActor() {
        std::unique_lock<std::mutex> lock(mutex);

        ActorType* actor = new ActorType(*this);
        actors.emplace(actorId, actor);
        actorId++;

        // Update routing strategy
        for (auto& strategy : routingStrategies) {
            strategy->updateActors(actors);
        }

        return *actor;
    }

    void addActor(int actorId, Actor* actor) {
        std::unique_lock<std::mutex> lock(mutex);

        actors.emplace(actorId, actor);

        // Update routing strategy
        for (auto& strategy : routingStrategies) {
            strategy->updateActors(actors);
        }
    }

    void removeActor(int actorId) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors.erase(actorId);

            // Update routing strategy
            for (auto& strategy : routingStrategies) {
                strategy->updateActors(actors);
            }
        }
    }

    void sendMessage(std::function<void()> message, RoutingStrategy* strategy = nullptr) {
        std::unique_lock<std::mutex> lock(mutex);

        int actorId = -1;

        if (strategy != nullptr) {
            actorId = strategy->selectActor(actors);
        } else {
            if (!actors.empty()) {
                actorId = actors.begin()->first;
            }
        }

        if (actorId != -1) {
            actors[actorId]->send(message);
        }
    }

    void stopActor(int actorId) {
        std::unique_lock<std::mutex> lock(mutex);

        if (actors.find(actorId) != actors.end()) {
            actors[actorId]->stopActor();
            delete actors[actorId];
            actors.erase(actorId);
        }
    }

    void addRoutingStrategy(RoutingStrategy* strategy) {
        routingStrategies.push_back(strategy);
        strategy->updateActors(actors);
    }

private:
    void run() {
        while (true) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));

            std::unique_lock<std::mutex> lock(mutex);

            for (const auto& actor : actors) {
                actor.second->run();
            }
        }
    }

    std::unordered_map<int, Actor*> actors;
    std::vector<RoutingStrategy*> routingStrategies;
    int actorId = 0;
    std::mutex mutex;
};

class MyActor {
public:
    MyActor(ActorSystem& actorSystem) : actorSystem(actorSystem) {
        actorSystem.addActor(actorId, this);
    }

    void doSomething(int value) {
        std::cout << "Actor " << actorId << " is doing something with value " << value << std::endl;
    }

private:
    int actorId;
    ActorSystem& actorSystem;
};

int main() {
    ActorSystem actorSystem;

    MyActor actor1(actorSystem);
    MyActor actor2(actorSystem);

    Actor& actor1Ref = actorSystem.createActor<MyActor>();
    Actor& actor2Ref = actorSystem.createActor<MyActor>();

    RoundRobinStrategy roundRobinStrategy;
    RandomStrategy randomStrategy;

    actorSystem.addRoutingStrategy(&roundRobinStrategy);
    actorSystem.addRoutingStrategy(&randomStrategy);

    actorSystem.sendMessage([&actor1]() {
        actor1.doSomething(1);
    }, &roundRobinStrategy);

    actorSystem.sendMessage([&actor2]() {
        actor2.doSomething(2);
    }, &randomStrategy);

    std::this_thread::sleep_for(std::chrono::seconds(5));

    actorSystem.stopActor(0);
    actorSystem.stopActor(1);

    return 0;
}