Akka - Uma plataforma para o desenvolvimento de sistemas concorrentes e distribuídos para a JVM

Uma plataforma para o desenvolvimento de sistemas
concorrentes e distribuídos para a JVM

Akka
• Daniel Capó Sobral
• Consultor pela Tecnisys
• Programador e Sysadmin
• Ex-committer FreeBSD
• Aficionado por Scala

Akka

Conheça Akka, uma plataforma para o JVM para
desenvolvimento de sistemas concorrentes e/ou
distribuídos através do paradigma de Atores.

Descreveremos o paradigma de atores, suas
vantagens e desvantagens, e mostraremos
exemplos da API em Java e em Scala, com
execução local e distribuída, memória transacional
e tolerância a falhas.

Conteúdo
Objetivos Principais

• O que é Akka?
• Para que serve?
• O que são atores?

Não é tema

• Ensinar Akka
• Ensinar programação com atores
• Mostrar todos os módulos de Akka

Uma cadeia de montanhas?
• “Akka” é uma cadeia de montanhas na Suécia

Um componente do Typesafe Stack?

Um componente do Typesafe Stack?
• A Typesafe foi fundada em 2011 pelos criadores da
linguagem de programação Scala e do middleware Akka.
• O Typesafe Stack contém Scala, Akka e ferramentas de
desenvolvimento, tudo open source.
• A Typesafe Subscription provê suporte comercial.

Uma solução de:

Concorrência

Escalabilidade

Tolerância à Falhas

Uma solução de:
Concorrência

• Atores
• STM
• Agentes
• Dataflow

Escalabilidade


Uma solução de:
Concorrência

Escalabilidade

• Vertical
• Atores
• Horizontal
• Atores Remotos
• Gestão de Cluster


Uma solução de:
Concorrência

Escalabilidade


• Supervisão de Atores
• Todos Por Um
• Cada Um Por Si
• “Deixe falhar”

Concorrência

Agentes

STM Dataflow

Atores

Atores
Erlang

• Popularizou o conceito
• 9 9s de disponibilidade

Scala

• Atores como prova de conceito

Akka

• Novo design
• Solução completa

Objetos vs Atores
Métodos

• Públicos
• Privados

Estado

• Rascunho
• Estático
• Dinâmico

Objetos vs Atores
Métodos

• Públicos
• Privados

Estado

• Rascunho
• Estático
• Dinâmico

Thread

• Orientado a eventos

Fatos sobre Atores
Orientados à eventos

• Assíncronos
• Threads próprios

Comunicação via mensagens

• Caixa de mensagens
• Não compartilham estado!

Baratos

• Atores não são threads
• Aproximadamente 600 bytes

Definindo um Ator - Java
public class SampleUntypedActor extends UntypedActor {
public void onReceive(Object message) throws Exception {
if (message instanceof String)
EventHandler.info(this, String.format("Received String
message: %s", message));
else
throw new IllegalArgumentException("Unknown
message: " + message);
}
}

Criando um Ator - Java

import static akka.actor.Actors.*;
ActorRef myActor = actorOf(SampleUntypedActor.class);
myActor.start();

// Construtor com parâmetros
ActorRef actor = actorOf(new UntypedActorFactory() {
public UntypedActor create() {
return new MyUntypedActor("service:name", 5);
}
}).start();

ActorRef vs Actor
Portabilidade

• Serializável
• Remote-aware

Opacidade

• Actor é membro privado de ActorRef

this vs self

• Actor this
• ActorRef self

Ciclo de Vida
• Não processa mensagens
New

• Iniciado com “start”
Started • Processa mensagens

• Iniciado com “exit” ou “stop”
Shutdown • Não pode fazer nada

Enviando uma mensagem
Envie e esqueça

• actor.sendOneWay("Hello");

Envie, com remetente

• actor.sendOneWay("Hello", getContext());

Envie, talvez receba resposta (ou exceção)

• Object result = actorRef.sendRequestReply("Hello", getContext(),
1000);

Envie, receba futuro

• Future future = actorRef.sendRequestReplyFuture("Hello",
getContext(), 1000);

Futuros
interface Future<T> {
void await();
boolean isCompleted();
boolean isExpired();
long timeoutInNanos();
Option<T> result();
Option<Throwable> exception();
Future<T> onComplete(Procedure<Future<T>> procedure);
}

Usando Futuros - Java
Future future = actorRef.sendRequestReplyFuture("Hello",
getContext(), 1000);
future.await();
if (future.isCompleted()) {
Option resultOption = future.result();
if (resultOption.isDefined()) {
Object result = resultOption.get();
...
}
... // whatever
}

Respondendo ao Remetente - Java
if (message instanceof String) {
String msg = (String)message;
if (msg.equals("Hello") &&
getContext().getSenderFuture().isDefined()) {
// Reply to original sender of message using the channel
getContext().channel().sendOneWay(msg + " from " +
getContext().getUuid());
}
}
}

Respondendo Mensagem - Java
if (message instanceof String) {
String msg = (String)message;
if (msg.equals("Hello")) {
if (getContext().replySafe(msg + " from " +
getContext().getUuid())) ... // success
else ... // handle failure
}
}
}

Parando um Ator - Java

actor.stop();

Akka em Scala
Concisão

• router.tell(new Work(arg, nrOfElements),
getContext());
• router ! Work(arg, nrOfElements)

Parâmetros “by-name”

• val a = actorOf(new MyActor(..)).start()

Parâmetros implícitos

• Ver exemplo de concisão acima!

Akka em Scala
Melhor suporte a imutabilidade

• case class Work(arg: Int,
nrOfElements: Int)
• Coleções imutáveis por default
• Estruturas de dados persistentes

Pattern matching

• case Work(arg, n) => // do stuff

Typed Actors
POJO -> TypedActors

• Requer Interface + Implementation

AOP

• AspectWerkz Proxy

Objetos -> Atores

• Métodos viram mensagens assíncronas!

Agentes
Inspirado nos Agentes de Clojure

Modificações Assíncronas

• Uma modificação de cada vez
• Modificações de cada origem processadas em ordem

Integrado ao STM

• Toma parte em transações

Futuros

• Valor “atual” após todas modificações enfileiradas

Agentes - Scala
Criando e Parando

• val agent = Agent(5)
• agent.close()

Alterando

• agent send 7
• agent send (_ + 1)

Lendo

• val result = agent()
• val result = agent.future.await.result.get

STM
Mutabilidade Controlada

• Estado compartilhado
• Transações multi-atores (transactors)

Modelo Clojure de Referências

Multiverse STM

STM - Java

final Ref<Integer> ref = new Ref<Integer>(0);

public int counter() {
return new Atomic<Integer>() {
public Integer atomically() {
int inc = ref.get() + 1;
ref.set(inc);
return inc;
}
}.execute();
}

Dataflow
Concorrência Determinística

• Mesmo resultado todas as vezes
• Baseado em futuros
• Scala Delimited Continuations

Derivado da linguagem Oz

Nada de efeitos colaterais!

• Exceções, data/hora, números aleatórios, etc

Dataflow - Scala
Declarar variável dataflow

• val x = Promise[Int]()

Usar valor

• flow { ... x() ... }

Assinalar valor

• flow { ... x << 5 ... }

Assinalar a uma outra variável

• flow { ... x << y ... }

Escalabilidade

Vertical

• Atores
• Dataflow

Horizontal

• Atores Remotos
• Gestão de Cluster

Atores Remotos - Java
// server code
class HelloWorldActor extends UntypedActor {
public void onReceive(Object msg) {
getContext().replySafe(msg + " World");
}
}
remote().start("localhost", 9999).register( "hello-
service", actorOf(HelloWorldActor.class));

// client code
ActorRef actor = remote().actorFor( "hello-
service", "localhost", 9999);
Object res = actor.sendRequestReply("Hello");

Atores Remotos

Um por tipo

Um por sessão

Um por requisição

Deixe falhar...

• Não se proteja de exceções
• Deixe outro lidar com o problema

Supervisores

• Erlang OTP
• Proteção em Profundidade

Estratégias de Supervisão

• OneForOne
• AllForOne

Estado

• Recuperável
• Não-recuperável

Ganchos de reinicialização

• Antes da reinicialização
• Depois da reinicialização

Ciclo de vida

• Permanente
• Temporário

Só isso?
Encaminhando mensagens
para outro Ator
• getContext().forward(message,
getContext());

Alterando o comportamento de
um ator
• become(scatter);
• actor ! HotSwap( self => { case message
=> self.reply("hotswapped body") })

Só isso?
Dispatcher

• Por eventos
• Por thread
• Eventos priorizados
• Eventos com work-stealing

Routing

• Dispatcher (roteador, não módulo)
• Load balance
• Actor pool

Futuros

• Usados por atores, agentes, dataflow e outros componentes

Só isso?

Crédito:
Palestra Above the
Clouds: Introducing Akka

Jonas Bonér

Mais informações...

http://akka.io

http://typesafe.com

Contato

Daniel Capó Sobral

• dcsobral@gmail.com
• http://dcsobral.blogspot.com/
• http://github.com/dcsobral
• @dcsobral

Akka - Uma plataforma para o desenvolvimento de sistemas concorrentes e distribuídos para a JVM

Recomendados

Recomendados

Mais conteúdo relacionado

Semelhante a Akka - Uma plataforma para o desenvolvimento de sistemas concorrentes e distribuídos para a JVM

Semelhante a Akka - Uma plataforma para o desenvolvimento de sistemas concorrentes e distribuídos para a JVM (20)

Mais de Daniel Sobral

Mais de Daniel Sobral (10)

Akka - Uma plataforma para o desenvolvimento de sistemas concorrentes e distribuídos para a JVM