Scala for Backend Engineering & Functional Programming · Aula

Fundamentos do modelo de atores do Akka

Compreenda os princípios do Modelo de Atores, o ciclo de vida dos atores e a troca de mensagens para execução concorrente.

Aula 1 de 312 etapas

Fundamentos do modelo de atores do Akka é uma aula grátis de Scala for Backend Engineering & Functional Programming no CoddyKit. Esta é a aula 1 de 3. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Scala for Backend Engineering & Functional Programming, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

Enfrentando desafios da concorrência

Em aplicações modernas, as tarefas frequentemente precisam ser executadas ao mesmo tempo. Isso é chamado de concorrência. Embora seja poderosa, a concorrência traz desafios.

Condições de corrida: ocorrem quando várias threads tentam acessar e modificar dados compartilhados simultaneamente, levando a resultados imprevisíveis.
Interbloqueios: ocorrem quando duas ou mais threads ficam bloqueadas indefinidamente, esperando que umas pelas outras liberem recursos.

Os modelos tradicionais de uso de threads podem ser complexos e propensos a erros ao lidar com esses problemas.

Entendendo o modelo de atores

O Modelo de Atores oferece uma maneira poderosa de gerenciar a concorrência. Em vez de compartilhar memória, os atores se comunicam apenas enviando mensagens uns aos outros.

Isolamento: cada ator tem seu próprio estado privado, ao qual nenhum outro ator pode ter acesso direto.
Passagem de mensagens: os atores interagem enviando mensagens imutáveis para as caixas de mensagens uns dos outros.
Assíncrono: o envio de mensagens não bloqueia; o remetente não espera por uma resposta.

Pense nos atores como pessoas independentes, cada uma com sua própria mesa (estado) e um serviço postal (passagem de mensagens).

Por que escolher o Akka?

Akka é um conjunto de ferramentas de código aberto que dá vida ao Modelo de Atores em Scala (e Java). Ele foi projetado para criar aplicações altamente concorrentes, distribuídas e tolerantes a falhas.

Simplicidade: o Akka simplifica a programação concorrente abstraindo os detalhes de baixo nível das threads.
Escalabilidade: permite expandir facilmente aplicações de uma única máquina para um cluster de máquinas.
Resiliência: possui mecanismos integrados para lidar com falhas, permitindo que os sistemas se recuperem automaticamente.

O Akka ajuda você a escrever sistemas que "simplesmente funcionam", mesmo sob carga intensa ou falhas parciais.

Por dentro de um ator do Akka

Um ator do Akka é uma unidade fundamental de concorrência. Cada ator tem:

Comportamento: definido pela forma como reage às mensagens.
Caixa de mensagens: onde as mensagens recebidas são enfileiradas. As mensagens são processadas uma por vez, na ordem.
Estado privado: dados que pertencem exclusivamente ao ator e só podem ser modificados pelo próprio ator.
ActorRef: um endereço exclusivo para enviar mensagens a esse ator.

Esse isolamento rigoroso evita erros comuns de concorrência, como condições de corrida.

Seu primeiro ActorSystem

Antes de criar atores, você precisa de um ActorSystem. Ele é o ponto de entrada do Akka e gerencia todos os atores dentro de seu escopo.

Ele fornece serviços como agendamento, configuração e uma hierarquia de supervisão (que abordaremos mais adiante).

Tente criar um:

import akka.actor.ActorSystem

object Main extends App {
  // Create an ActorSystem
  val system = ActorSystem("MyActorSystem")
  println(s"ActorSystem created: ${system.name}")

  // Terminate the system when done (important for clean shutdown)
  system.terminate()
}

Criando seu primeiro ator

Para criar um ator, você define uma classe que estende o traço Actor do Akka e implementa o método receive.

O método receive define como seu ator processa as mensagens recebidas. É uma função parcial que corresponde aos tipos de mensagem.

import akka.actor.Actor

class GreeterActor extends Actor {
  def receive: Receive = {
    case message: String =>
      println(s"Greeter received: $message")
  }
}

Criando atores e ActorRef

Os atores são criados (ou "iniciados") usando o método actorOf do ActorSystem. Esse método retorna um ActorRef.

Um ActorRef é uma referência leve e serializável para um ator. Você a usa para enviar mensagens a esse ator, sem nunca interagir diretamente com a instância do ator.

import akka.actor.{ActorSystem, Props, Actor}

class GreeterActor extends Actor {
  def receive: Receive = {
    case message: String =>
      println(s"Greeter received: $message")
  }
}

object Main extends App {
  val system = ActorSystem("MyActorSystem")

  // Create an actor and get its ActorRef
  val greeterRef = system.actorOf(Props[GreeterActor], "greeter")
  println(s"Greeter actor created with path: ${greeterRef.path}")

  system.terminate()
}

Enviando mensagens aos atores

A comunicação entre atores acontece exclusivamente por meio de mensagens. Você envia mensagens para um ActorRef usando o operador ! (tell).

As mensagens são enviadas de forma assíncrona e geralmente são classes de caso imutáveis ou tipos simples, como String.

import akka.actor.{ActorSystem, Props, Actor}

class GreeterActor extends Actor {
  def receive: Receive = {
    case message: String =>
      println(s"Greeter received: $message")
  }
}

object Main extends App {
  val system = ActorSystem("MyActorSystem")

  val greeterRef = system.actorOf(Props[GreeterActor], "greeter")

  // Send a message to the greeter actor
  greeterRef ! "Hello Akka!"
  greeterRef ! "How are you?"

  // Give actors time to process messages before terminating
  Thread.sleep(100)
  system.terminate()
}

Noções básicas do ciclo de vida dos atores

Os atores têm um ciclo de vida, que vai da criação à terminação. O Akka fornece pontos de extensão para que você execute ações de configuração e limpeza:

preStart(): chamado imediatamente antes de o ator começar a processar sua primeira mensagem. É útil para inicializar recursos.
postStop(): chamado depois que o ator foi interrompido e antes de ser completamente removido do sistema. É útil para liberar recursos.

Compreender o ciclo de vida é essencial para gerenciar os recursos dos atores de forma eficiente.

Hierarquias de atores

Os atores são organizados em uma hierarquia, de modo semelhante a um sistema de arquivos. Todo ator, exceto o ator "guardião raiz", tem um pai.

Supervisão: os atores pais são responsáveis por supervisionar seus filhos. Se um ator filho falhar, seu pai decide como lidar com a falha (por exemplo, reiniciá-lo ou interrompê-lo).
Caminho: cada ator tem um caminho exclusivo, como /user/myActor/childActor, que representa sua posição na hierarquia.

Essa hierarquia é fundamental para os recursos de tolerância a falhas e resiliência do Akka.

Verificação dos fundamentos do Akka

Vamos testar sua compreensão dos fundamentos do Modelo de Atores do Akka.

Responda na aula interativa

Recapitulação: Modelo de Atores do Akka

Excelente trabalho! Nesta lição, você aprendeu os conceitos fundamentais do Modelo de Atores do Akka:

Os desafios da concorrência tradicional.
Os princípios do Modelo de Atores: isolamento, troca de mensagens e ausência de estado compartilhado.
O papel do Akka como um conjunto de ferramentas para criar sistemas robustos de atores.
Como definir um ActorSystem e atores simples em Scala.
Como criar atores e enviar mensagens para eles usando um ActorRef.
Os fundamentos do ciclo de vida e da hierarquia dos atores.

Em seguida, vamos aprofundar o design de sistemas de atores e o tratamento de interações mais complexas!

Grátis para começar

Aprenda Scala com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 39
Aulas: 143

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Fundamentos do modelo de atores do Akka” é grátis?

Sim — o texto completo de “Fundamentos do modelo de atores do Akka” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Scala for Backend Engineering & Functional Programming, atualize para CoddyKit PRO. O curso de Scala for Backend Engineering & Functional Programming inclui 3 aulas no total.

O que vou aprender em “Fundamentos do modelo de atores do Akka”?

Compreenda os princípios do Modelo de Atores, o ciclo de vida dos atores e a troca de mensagens para execução concorrente. Você pratica Scala for Backend Engineering & Functional Programming com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Scala for Backend Engineering & Functional Programming?

Nenhuma experiência prévia é necessária. Scala for Backend Engineering & Functional Programming no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 3.

Quanto tempo leva a aula “Fundamentos do modelo de atores do Akka”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Scala for Backend Engineering & Functional Programming?

Sim. Cada aula de Scala for Backend Engineering & Functional Programming inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Scala for Backend Engineering & Functional Programming