Akka.Net-EndpointWriter forYou中的缓冲消息可能应该实现流控制以避免淹没远程连接

Question

我使用Akka.Cluster创建了两个单独的控制台应用程序，一个是服务器，另一个是客户端。

我想使用多个客户端应用程序分布式执行消息。

当我同时运行两个应用程序时，出现以下错误：

在EndpointWriter中为[akka.tcp：//ClusterSystem@127.0.0.1：52635]缓存的邮件。您可能应该实施流控制，以避免淹没远程连接。

这是我的服务器。hocon

    akka {
       actor.provider = cluster

       actor.deployment {
                /tasker {
                    router = consistent-hashing-group
                    routees.paths = ["/user/api"]
                    virtual-nodes-factor = 8
                    cluster {
                            enabled = on
                            max-nr-of-instances-per-node = 2
                            allow-local-routees = off
                            use-role = tracker
                    }
                }                
            }

        remote {
            dot-netty.tcp {
                port = 8081
                hostname = localhost
            }
        }

        cluster {
           seed-nodes = ["akka.tcp://akkatest@192.168.1.117:8081", "akka.tcp://akkatest@192.168.1.17:8081"] # address of seed node
           roles = ["akkatest"] # roles this member is in
           role.["akkatest"].min-nr-of-members = 3 # crawler role minimum node count
        }
    }

这是我的客户。hocon

    akka {
        actor {
            provider = cluster

            deployment {
                /tasker {
                    router = round-robin-pool
                    nr-of-instances = 2
                    // routees.paths = ["/user/tasker"]
                    // virtual-nodes-factor = 8
                }                
            }
        }

        remote {
            dot-netty.tcp {
                hostname = "127.0.0.1"
                port = 0
                maximum-frame-size = 256000b
            }
        }            

        cluster {
            #will inject this node as a self-seed node at run-time
            seed-nodes = ["akka.tcp://ClusterSystem@localhost:12345"]
            roles = ["tasker"]
        }
    }

服务器代码

    class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Akka Server Started.");

        var actor = StartServer();
        //StartNormalProcess();

        Console.ReadLine();

        InjectActor(actor);

        Console.ReadLine();
    }

    public static IActorRef StartServer()
    {
        Config config = Utility.ParseConfig("server.hocon");
        ActorSystem actorSystem = ActorSystem.Create("ClusterSystem", config);

        //var router = actorSystem.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "tasker");
        IActorRef myActor = actorSystem.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "tasker");
        //var props = Props.Create<MyActor>(); //.WithRouter(new RoundRobinPool(5));
        //IActorRef myActor = actorSystem.ActorOf(props, "myactor");
        return myActor;
    }

    public static void InjectActor(IActorRef actor)
    {
        Console.WriteLine("Injecting actor");

        int n = 200000;
        Random random = new Random();
        for (int i = 1; i <= n; i++)
        {
            var tradeData = new TradeData
            {
                UserId = i,
                Qty = random.Next(1000, 5000),
                Rate = random.Next(100, 1000)
            };

            actor.Tell(tradeData);
        }
    }

    public static void StartNormalProcess()
    {
        new Process().ProcessData();
    }
}

客户代码

    class Program
{
    static void Main(string[] args)
    {
        Console.WriteLine("Akka Client Started.");

        StartClient();

        Console.ReadLine();
    }

    public static void StartClient()
    {
        //Config config = Utility.ParseConfig("client.hocon");
        //ActorSystem actorSystem = ActorSystem.Create("ClusterSystem", config);
        //var router = actorSystem.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "tasker");
        //var props = Props.Create<MyActor>(); //.WithRouter(new RoundRobinPool(5));
        //IActorRef myActor = actorSystem.ActorOf(props, "myactor");

        Config config = Utility.ParseConfig("client.hocon");
        ActorSystem actorSystem = ActorSystem.Create("ClusterSystem", config);
        IActorRef myActor = actorSystem.ActorOf(Props.Empty.WithRouter(FromConfig.Instance), "tasker");


    }
}

MyActor.cs

    public class MyActor : UntypedActor
{
    protected Cluster cluster = Cluster.Get(Context.System);

    protected override void OnReceive(object message)
    {
        var up = message as ClusterEvent.MemberUp;
        if (up != null)
        {
            var mem = up;
            //Become(mem);
            Console.WriteLine("Member is Up: {0}", mem.Member);
        }
        else if (message is ClusterEvent.UnreachableMember)
        {
            var unreachable = (ClusterEvent.UnreachableMember)message;
            Console.WriteLine("Member detected as unreachable: {0}", unreachable.Member);
        }
        else if (message is ClusterEvent.MemberRemoved)
        {
            var removed = (ClusterEvent.MemberRemoved)message;
            Console.WriteLine("Member is Removed: {0}", removed.Member);
        }
        else if (message is ClusterEvent.IMemberEvent)
        {
            //IGNORE
        }
        else if (message is ClusterEvent.CurrentClusterState)
        {

        }
        else if (message is TradeData)
        {
            TradeData tradeData = message as TradeData;
            double price = new Process().getTradePrice(tradeData.Qty, tradeData.Rate);

            string logMessage = "Trade Price for UserId: {0} is Qty({1}) * Rate({2}) = {3} -- Process executed by Worker: {4}";
            logMessage = String.Format(logMessage, tradeData.UserId, tradeData.Qty, tradeData.Rate, price, Context.Self.Path.Name);

            Console.WriteLine(logMessage);
        }
        else
        {
            Unhandled(message);
        }
    }

    protected override void PreRestart(Exception reason, object message)
    {
        cluster.Subscribe(Self, ClusterEvent.InitialStateAsEvents, new[] { typeof(ClusterEvent.IMemberEvent), typeof(ClusterEvent.UnreachableMember) });
    }

    protected override void PostRestart(Exception reason)
    {
        base.PostRestart(reason);
    }

    protected override void PreStart()
    {
        cluster.Subscribe(Self, ClusterEvent.InitialStateAsEvents, new[] { typeof(ClusterEvent.IMemberEvent), typeof(ClusterEvent.UnreachableMember) });
        Console.WriteLine("Cluster Subscribed");
    }

    protected override void PostStop()
    {
        cluster.Unsubscribe(Self);
        Console.WriteLine("Cluster Unsubscribed");
    }

    protected override void Unhandled(object message)
    {
        base.Unhandled(message);
    }
}

请帮助我了解如何在多个客户端应用程序中分布式执行消息。