The Actor is the unit of execution in Akka. Actors are object-oriented in the sense that they encapsulate state and behavior, but they have much stronger isolation than regular objects in Java or Scala.

The Actor model prevents sharing state between Actors and the only way to observe another actor‘s state is by sending it a message asking for it.

Actor模型限制分Actor們之間的共享狀態, 唯一觀察其他actor的方法是對它發送一個asking訊息.

Actors are extremely lightweight, they are only constrained by memory of which they consume only a few hundred bytes each — this means you can easily create millions of concurrent Actors in a single application. Their strong isolation principles together with the event-driven model (that we will talk about later on) and location transparency makes it easy to solve hard concurrency and scalability problems in an intuitive way.

Actors是極度輕量的, 他們只消費幾百個字節在內存的限制當中- 那表示你可以在一個簡單的應用程序輕松地建立數以百萬個並發Actors. 他們強大的隔離原則, 再加上事件驅動模型以及位置透明度使它很輕松地以直覺的方式去處理硬並發與可擴展性問題.

You create an Actor in Java by defining a class that extendsUntypedActor and implement the onReceive method (in Scala you have to extend Actor trait and implement the receive method). It is in theonReceive method that you define the behavior; how the Actor should react to the different messages it receives. An Actor can have — and often has — state. Accessing or mutating the internal state of an Actor is fully thread safe since protected by the Actor model.

So, let‘s now create a Greeter Actor with a single variable greeting as its state, holding on to the latest defined greeting, and in its onReceivemethod let‘s add the behavior for how it should react upon receiving the WhoToGreet and the Greet messages.

Let‘s start by creating our Actor in Java (you can find the code in the HelloAkkaJava.java file):

// Java code

public static class Greeter extends UntypedActor {
    String greeting = "";

    public void onReceive(Object message) {
        if (message instanceof WhoToGreet)
            greeting = "hello, " + ((WhoToGreet) message).who;

        else if (message instanceof Greet)
            getSender().tell(new Greeting(greeting), getSelf());

        else unhandled(message);
    }
}

Actors like this one are “untyped” in the sense that the type of message received is not restricted—it is Object as shown above. There are also typed actors, but we will not concern ourselves with those now, the normal actors are the untyped ones.

Don‘t worry about the getSender(), tell(..) and getSelf() API calls, we will get to that soon when we talk about sending and replying to messages.

Now let‘s implement it in Scala. As you can see, Scala‘s pattern matching features really simplify working with Actors, but apart from that it‘s pretty similar to the Java version (you can find the code in theHelloAkkaScala.scala file).

// Scala code

class Greeter extends Actor {
  var greeting = ""

  def receive = {
    case WhoToGreet(who) => greeting = s"hello, $who"
    case Greet           => sender ! Greeting(greeting)
  }
}

You will notice one difference to the Java version: here we do not explicitly pass unhandled messages to the unhandled() method. This is not necessary since the behavior defined by the receive method is expressed as a so-called partial function, which means that all messages for which no matching case statement is written down will be recognized as being not handled and Akka will automatically pass them to the unhandled() method for you.

Another difference is that the trait from which the Scala actor inherits is just called Actor. This is the Scala API while UntypedActor is the Java API for the same kind of actor.