java - Akka actor model. Why sending messages to self?

Question

I am new to akka, looking at existing code and see an actor gets Message1 form others and then sends Message2 to self. I understand the advantage of sending messages over method calls is the key in akka. However I do not see advantage in sending message to getSelf(). The code I see looks like this:

import java.util.Date;

import akka.actor.AbstractLoggingActor;
import akka.actor.Props;

public class myActor extends AbstractLoggingActor {
    public static class Message1 {
    }

    public static class Message2 {
    }

    private Date date;

    public static Props props(Date date) {
        return Props.create(myActor.class, date);
    }

    @Override
    public Receive createReceive() {
        return receiveBuilder().match(Message1.class, message -> {
            // some state change here, method calls, ...
            getSelf().tell(new Message2(), getSelf());
        }).match(Message2.class, message -> {
            // some code here ...
            this.doSomeLongProcessing();
        }).build();
    }

    private void doSomeLongProcessing() {
        // ... long time is taken here
    }

}

Eventually there should be a blocking call to a method in the actor class (e.g. doSomeLongProcessing()) and we put this call in another message processing it will not be any better.

In this light the question is - why we may need to send messages to self in akka ? Please explain as I saw some examples of this on the web as well.

Answer 1

I don't think I can give a real answer without seeing the complete code and context. But, in general, you are right, under normal circumstances there's not a whole lot of benefit to sending yourself a message just to continue normal processing. But I expect that this example is a bit contrived anyway because ordinarily you wouldn't want to mix blocking and non-blocking behavior in the same actor. (In general, the best practice would be to process message1 in one actor and then process message2 in a different actor so that you could put that second actor in a dedicated thread pool for blocking actors.)

There are several situations, however, where sending messages to yourself can be valid. Two of which are mentioned by Robert Harvey above in the comments: when using timers to send a message to yourself in the future and the "pipeTo" pattern where you are sending yourself a message from inside a Future completion. (This is important because you will no longer be inside the actor context in the completion handler, so you need to send yourself a message in order to get back into the context.)

I can also think of a few other edge cases where you might want to send a message to self. For example, if you are in a blocking actor, sending a message to yourself is effectively a yield allowing the actor to handle others messages.

If the code is public I could take a look at a specific example in more detail.