Akka Actors in Scala

In this lesson, you will learn about Akka Actors, a powerful model for building concurrent, distributed, and fault-tolerant applications in Scala.

The Actor model helps you write scalable systems by avoiding shared mutable state and using message passing instead.

What Is the Actor Model?

The Actor model is a concurrency paradigm where:

• Actors are independent units of computation
• Actors communicate only by sending messages
• No shared mutable state exists between actors

Each actor processes messages one at a time, making concurrency easier and safer.

Why Use Akka?

Akka is a toolkit and runtime for building actor-based systems on the JVM.

Akka provides:

• High scalability
• Built-in fault tolerance
• Location transparency
• Asynchronous, non-blocking execution

Akka is widely used in high-performance systems such as streaming platforms, financial systems, and distributed services.

Key Concepts in Akka

• Actor – a unit that processes messages
• Message – immutable data sent between actors
• ActorSystem – manages actors and their lifecycle
• Mailbox – queue that stores incoming messages

Adding Akka Dependency

To use Akka, you must add it to your build configuration.

Example for build.sbt:

libraryDependencies += "com.typesafe.akka" %% "akka-actor" % "2.6.21"

Creating an Actor

Actors are defined by extending the Actor trait.

import akka.actor.Actor

class HelloActor extends Actor {
  def receive: Receive = {
    case "hello" => println("Hello from Actor")
  }
}

The receive method defines how an actor handles messages.

Creating an ActorSystem

An ActorSystem is required to create and manage actors.

import akka.actor.ActorSystem

val system = ActorSystem("MyActorSystem")

Creating an Actor Instance

Actors are created using Props.

import akka.actor.Props

val helloActor = system.actorOf(Props[HelloActor], "helloActor")

Sending Messages to an Actor

Messages are sent asynchronously using the ! operator.

helloActor ! "hello"

This is known as fire-and-forget messaging.

Using Case Classes for Messages

It is best practice to use case classes for messages.

case class Greet(name: String)

class GreetingActor extends Actor {
  def receive: Receive = {
    case Greet(name) => println(s"Hello, $name")
  }
}

Actor State

Actors can maintain internal state safely. Only one message is processed at a time.

class CounterActor extends Actor {
  var count = 0

  def receive: Receive = {
    case "increment" =>
      count += 1
      println(count)
  }
}

Actor Lifecycle

Actors go through different lifecycle stages:

• Creation
• Message processing
• Restart (on failure)
• Termination

Akka supervises actors and restarts them automatically when failures occur.

Stopping an Actor

Actors can be stopped gracefully.

system.stop(helloActor)

Why Actors Scale Well

• No shared mutable state
• Asynchronous message passing
• Efficient scheduling
• Built-in fault tolerance

Real-World Use Cases

• Chat systems
• Streaming pipelines
• Microservices
• Event-driven architectures

📝 Practice Exercises

Exercise 1

Create an actor that prints any message it receives.

Exercise 2

Create a counter actor that increments on each message.

Exercise 3

Send different case class messages to an actor.

✅ Practice Answers

Answer 1

class PrintActor extends Actor {
  def receive: Receive = {
    case msg => println(msg)
  }
}

Answer 2

class Counter extends Actor {
  var count = 0
  def receive = {
    case "inc" => count += 1
  }
}

Answer 3

case class Add(x: Int)

class MathActor extends Actor {
  def receive = {
    case Add(x) => println(x + 1)
  }
}

What’s Next?

In the next lesson, you will learn about Streams and how Scala processes continuous data efficiently.