如何一次调用两个参与者，即并行？

Question

I have a scenario where two functionalities run parallel.

Below is sample pseudo code.

MainActor{
 // retrive company ids
 //for each company id i need to run another two different actions simultaniously 
   tell(A_Actor)
   tell(B_Actor)
//if I call above they are calling sequentially i.e. first it runs tell(A_Actor)
//then comes to tell(B_Actor).
//If tell(A_Actor) fails it wont run tell(B_Actor).
}
A_Actor{
// do ingest into a file.
}

B_Actor{
// do ingest into a DB.
}

Question : How to run two functionalities ie tell(A_Actor) & tell(B_Actor) run parallel?

Answer 1

The tell method is asynchronous. When you fire a tell to actorA , it doesn't wait until actorA finishes or crashes to execute the next action, which here is to tell actorB

If you need to paralelize the two tell methods, then you can do the following :

    val tellActions = Vector(() => actorA.tell(messageA, senderActor), () => actorB.tell(messageB, senderActor))
    tellActions.par.foreach(_.apply())

Note that this is Scala code

Answer 2

This has been pointed out in several comments (including mine), but I felt it deserved an answer.

In short, you need to distinguish between calling the tell method in parallel with the functionality that the actors execute within their receive methods being executed in parallel. The functionality will be executed in parallel automatically, and calling the tell method in parallel doesn't make any sense.

The code you show will execute the ingest in a file and ingest into the DB in parallel. This is automatic and requires no action on your part; this is how actors and tell works. And, despite what you say, if something goes wrong with the file ingestion it will not affect the ingestion into the DB. (Assuming you built the actors and messages correctly, since you don't list their implementation.)

The tell method is asynchronous: it returns nearly immediately and doesn't do the actual logic (ingestion in this case): the only thing it does is place the message in the recipient's mailbox. Ismail's answer, in theory, shows you how you could "invoke tell " in parallel, but in that example you "sequentially" are creating the array that is used for parallel tells and the whole process will be very inefficient.) His code, while technically doing what you ask, is nonsensical in practice: it accomplishes nothing except slowing the code down significantly.

In short, I think you either:

• Have something fundamentally wrong with your actors and how you are calling them.
• You are actually are executing the functionality in parallel and you just aren't realizing it because you are measuring/observing something incorrectly.