在阿卡安排儿童演员

Question

我是Akka的新手，我想知道我应该如何处理将工作委托给其他（儿童）演员的演员，但在哪里：

1. 其中一些儿童演员必须按特定顺序参与；和
2. 其中一些子参与者可以以任何顺序参与，并且可以真正地与主/父参与者所做的事情异步执行

假设我有以下儿童演员（不管他们做什么）：

// Grovy pseudo code
class ActorA extends UntypedActor {
    @Override
    void onReceive(Object message) {
        if(message instanceof RunActorA) {
            …
    }
}
class ActorB extends UntypedActor {
    @Override
    void onReceive(Object message) {
        if(message instanceof RunActorB) {
            …
    }
}
class ActorC extends UntypedActor {
    @Override
    void onReceive(Object message) {
        if(message instanceof RunActorC) {
            …
        }
    }
class ActorD extends UntypedActor {
    @Override
    void onReceive(Object message) {
        if(message instanceof RunActorD) {
            …
        }
    }

假设我有以下调用它们的父参与者：

class MasterParent extends UntypedActor {
    ActorRef actorA
    ActorRef actorB
    ActorRef actorC
    ActorRef actorD

    MasterParent(ActorRef actorA, ActorRef actorA, ActorRef actorA, ActorRef actorA) {
        super()

        this.actorA = actorA
        this.actorB = actorB
        this.actorC = actorC
        this.actorD = actorD
    }

    @Override
    void onReceive(Object message) {
        if(message instanceof ProcessData) {
            ProcessData pData = message as ProcessData
            Widget widget = pData.widget
            RunActorA runA = new RunActorA(widget)

            actorA.tell(runA, self)

            // Somehow obtain a result from A, perhaps an “ResultOfA” object.
            ResultOfA resultA = ??? // get from ActorA

            RunActorB runB = new RunActorB(resultA)
            RunActorC runC = new RunActorC(resultA)

            actorB.tell(runB, self)
            actorC.tell(runC, self)

            // Somehow wait until both B and C return a result, say, ResultOfB and ResultOfC, respectively.
            ResultOfB resultB = ??? // get from ActorB
            ResultOfC resultC = ??? // get from ActorC

            RunActorD runD = new RunActorD(resultB, resultC)

            actorD.tell(runD, self)
        }
    }
}

如你所见：

• ActorA必须首先“参与”（由家长调用），我们必须等待家长的响应，然后才能继续参与/调用ActorB、ActorC或ActorD

换句话说，当ProcessData消息被MasterParent接收时：

1. 运行ActorA，等待它返回结果；然后

我的主要问题是：如何实现这一点（Java伪代码或非常受欢迎的示例！）？

第二，更重要的是值得商榷，因为我对演员来说太陌生了：这种亲子配乐在阿卡是“正常”的吗？或者，Akka的最佳实践是否通常规定所有子级都异步运行，并且没有强加的顺序/顺序/编排？

Answer 1

首先，是的，因为母公司将工作委托给其他演员，所以让他们作为子演员是有意义的。

你对ResultOfA的想法也离我们不远。

这是一种方法：

ResultOfB resultB = null;
ResultOfC resultC = null;

@Override
void onReceive(Object message) {
    if(message instanceof ProcessData) {
        ProcessData pData = message as ProcessData

        resultB = null;
        resultC = null;

        Widget widget = pData.widget
        RunActorA runA = new RunActorA(widget)

        actorA.tell(runA, self)
    } else if (message instanceof ResultOfA) {
        ResultOfA resultA = message as ResultOfA

        actorB.tell(resultA)
        actorC.tell(resultA)
    } else if (message instanceof ResultOfB) {
        resultB = message as ResultOfB

        if (resultC != null) {
            actorD.tell(composedResultBAndC)
        }
    } else if (message instanceof ResultOfC) {
        resultC = message as ResultOfC

        if (resultB != null) {
            actorD.tell(composedResultBAndC)
        }
    } else if (message instanceof ResultOfD) {
        //Do stuff with the result
    }
}

每个子角色都会执行sender（）。告诉（resultX），以便主机接收结果。

ResultB和ResultC都是必需的，因此我在actor中保存了一些状态，在ProcessData的每个新实例上都设置为null，因此在这种情况下不可能将多个ProcessData发送到一个MasterParent。

如果您希望在不等待的情况下将多个ProcessData消息发送给一个MasterParent，则需要使其不处于状态，因此可以在actorB和actorC上使用Ask模式，并一起解析返回的未来。比如：

Future futureA = actorB.ask(resultA)
Future futureB = actorC.ask(resultA)

然后编写它们并注册一个回调，在那里向actorD发送请求。

这段代码是伪代码，因此无法运行。