SlideShare une entreprise Scribd logo
1  sur  180
Télécharger pour lire hors ligne
Introducing

         Jonas Bonér
          CTO Typesafe
Introducing
Introducing

                Akka (Áhkká)
  The name comes from the goddess in the Sami
  (native swedes) mythology that represented all
        the wisdom and beauty in the world.

   It is also the name of a beautiful mountain in
         Laponia in the north part of Sweden
Introducing
Vision

Simpler
     Concurrency
     Scalability
     Fault-tolerance
Vision

...with a single unified
     Programming Model
     Managed Runtime
     Open Source Distribution
Manage System Overload
Scale UP & Scale OUT
Program at a Higher Level
Program at a Higher Level
Program at a Higher Level
• Never think in terms of shared state, state
   visibility, threads, locks, concurrent collections,
   thread notifications etc.
Program at a Higher Level
• Never think in terms of shared state, state
   visibility, threads, locks, concurrent collections,
   thread notifications etc.
• Low level concurrency plumbing BECOMES
   SIMPLE WORKFLOW - you only think about how
   messages flow in the system
Program at a Higher Level
• Never think in terms of shared state, state
   visibility, threads, locks, concurrent collections,
   thread notifications etc.
• Low level concurrency plumbing BECOMES
   SIMPLE WORKFLOW - you only think about how
   messages flow in the system
• You get high CPU utilization, low latency, high
   throughput and scalability - FOR FREE as part of
   the model
Program at a Higher Level
• Never think in terms of shared state, state
   visibility, threads, locks, concurrent collections,
   thread notifications etc.
• Low level concurrency plumbing BECOMES
   SIMPLE WORKFLOW - you only think about how
   messages flow in the system
• You get high CPU utilization, low latency, high
   throughput and scalability - FOR FREE as part of
   the model
• Proven and superior model for detecting and
   recovering from errors
Distributable by Design
Distributable by Design
Distributable by Design
• Actors are location transparent & distributable by design
Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
 -   elastic & dynamic
Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
 -   elastic & dynamic

 -   fault-tolerant & self-healing
Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
 -   elastic & dynamic

 -   fault-tolerant & self-healing

 -   adaptive load-balancing, cluster rebalancing & actor migration
Distributable by Design
• Actors are location transparent & distributable by design
• Scale UP and OUT for free as part of the model
• You get the PERFECT FABRIC for the CLOUD
 -   elastic & dynamic

 -   fault-tolerant & self-healing

 -   adaptive load-balancing, cluster rebalancing & actor migration

 -   build extremely loosely coupled and dynamic systems that can
     change and adapt at runtime
Selection of Akka Production Users
Introducing Akka
How
can we achieve this?
How
can we achieve this?
Let’s use Actors




     How
can we achieve this?
What is an Actor?
What is an Actor?
What is an Actor?
• Akka's unit of code organization is called an Actor
What is an Actor?
• Akka's unit of code organization is called an Actor
• Actors helps you create concurrent, scalable and
   fault-tolerant applications
What is an Actor?
• Akka's unit of code organization is called an Actor
• Actors helps you create concurrent, scalable and
   fault-tolerant applications

• Like Java EE servlets and session beans, Actors is a
   model for organizing your code that keeps many
   “policy decisions” separate from the business logic
What is an Actor?
• Akka's unit of code organization is called an Actor
• Actors helps you create concurrent, scalable and
   fault-tolerant applications

• Like Java EE servlets and session beans, Actors is a
   model for organizing your code that keeps many
   “policy decisions” separate from the business logic

• Actors may be new to many in the Java community,
   but they are a tried-and-true concept (Hewitt 1973)
   used for many years in telecom systems with 9 nines
   uptime
Introducing Akka
Actors can be seen as
Virtual Machines (nodes)
  in Cloud Computing
Introducing Akka
Encapsulated
and decoupled
 black boxes...
Encapsulated
and decoupled
 black boxes...
Introducing Akka
...that manages their own
   memory and behavior
...that manages their own
   memory and behavior
Introducing Akka
Communicates
with asynchronous
   non-blocking
     messages
Communicates
with asynchronous
   non-blocking
     messages
Introducing Akka
Elastic - grow and
shrink on demand
Elastic - grow and
shrink on demand
Elastic - grow and
shrink on demand
Elastic - grow and
shrink on demand
Introducing Akka
Hot deploy - change
behavior at runtime
Hot deploy - change
behavior at runtime
Now - if we replace

             with
                    Actor
EVERYTHING will STILL HOLD for both
  LOCAL and DISTRIBUTED Actors
What can I use Actors for?
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread

  -   an object instance or component
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread

  -   an object instance or component

  -   a callback or listener
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread

  -   an object instance or component

  -   a callback or listener

  -   a singleton or service
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread

  -   an object instance or component

  -   a callback or listener

  -   a singleton or service

  -   a router, load-balancer or pool
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread

  -   an object instance or component

  -   a callback or listener

  -   a singleton or service

  -   a router, load-balancer or pool

  -   a Java EE Session Bean or Message-Driven Bean
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread

  -   an object instance or component

  -   a callback or listener

  -   a singleton or service

  -   a router, load-balancer or pool

  -   a Java EE Session Bean or Message-Driven Bean

  -   an out-of-process service
What can I use Actors for?
 In different scenarios, an Actor may be an
 alternative to:
  -   a thread

  -   an object instance or component

  -   a callback or listener

  -   a singleton or service

  -   a router, load-balancer or pool

  -   a Java EE Session Bean or Message-Driven Bean

  -   an out-of-process service

  -   a Finite State Machine (FSM)
So, what is the
Actor Model?
Carl Hewitt’s definition




    http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:




                http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:
    -   Processing




                     http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:
    -   Processing

    -   Storage




                     http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:
    -   Processing

    -   Storage

    -   Communication




                     http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:
    -   Processing

    -   Storage

    -   Communication

-   3 axioms - When an Actor receives a message it can:




                     http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:
    -   Processing

    -   Storage

    -   Communication

-   3 axioms - When an Actor receives a message it can:
    -   Create new Actors




                     http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:
    -   Processing

    -   Storage

    -   Communication

-   3 axioms - When an Actor receives a message it can:
    -   Create new Actors

    -   Send messages to Actors it knows



                     http://bit.ly/hewitt-on-actors
Carl Hewitt’s definition
-   The fundamental unit of computation that embodies:
    -   Processing

    -   Storage

    -   Communication

-   3 axioms - When an Actor receives a message it can:
    -   Create new Actors

    -   Send messages to Actors it knows

    -   Designate how it should handle the next message it receives

                     http://bit.ly/hewitt-on-actors
4 core Actor operations
       0. DEFINE
       1. CREATE
       2. SEND
       3. BECOME
       4. SUPERVISE
0. DEFINE
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
}
0. DEFINE
                        Define the message(s) the Actor
                         should be able to respond to


public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
}
0. DEFINE
                        Define the message(s) the Actor
                         should be able to respond to


public class Greeting implements Serializable {
   public final String who;
                        Define the Actor class
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
}
0. DEFINE
                        Define the message(s) the Actor
                         should be able to respond to


public class Greeting implements Serializable {
   public final String who;
                        Define the Actor class
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
                            Define the Actor’s behavior
}
Scala version
case class Greeting(who: String)

class GreetingActor extends Actor with ActorLogging {
  def receive = {
    case Greeting(who) => log.info("Hello {}", who)
  }
}
1. CREATE
• CREATE - creates a new instance of an Actor
• Extremely lightweight (2.7 Million per Gb RAM)
• Very strong encapsulation - encapsulates:
  -    state

  -    behavior

  -    message queue

• State & behavior is indistinguishable from each other
• Only way to observe state is by sending an actor a
  message and see how it reacts
CREATE Actor
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
CREATE Actor
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }             Create an Actor system
    }
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
CREATE Actor
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }             Create an Actor system
    }                                             Actor configuration
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
CREATE Actor
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }             Create an Actor system
    }                                             Actor configuration
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");



                                                          Give it a name
CREATE Actor
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }             Create an Actor system
    }                                              Actor configuration
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");


                                       Create the Actor
                                                           Give it a name
CREATE Actor
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }             Create an Actor system
    }                                              Actor configuration
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");


                                       Create the Actor
           You get an ActorRef back                        Give it a name
Actors can form hierarchies
          Guardian System Actor
Actors can form hierarchies
          Guardian System Actor




          system.actorOf(Props[Foo], “Foo”)
Actors can form hierarchies
             Guardian System Actor




       Foo   system.actorOf(Props[Foo], “Foo”)
Actors can form hierarchies
               Guardian System Actor




       Foo




             context.actorOf(Props[A], “A”)
Actors can form hierarchies
               Guardian System Actor




       Foo




      A      context.actorOf(Props[A], “A”)
Actors can form hierarchies
             Guardian System Actor




       Foo                           Bar




                                           A
      A          C




             E                                 C
B
                                     B

      D
Name resolution - like a file-system
                Guardian System Actor




          Foo                           Bar




                                              A
          A         C




                E                                 C
    B
                                        B

          D
Name resolution - like a file-system
                     Guardian System Actor



        /Foo

               Foo                           Bar




                                                   A
               A         C




                     E                                 C
    B
                                             B

               D
Name resolution - like a file-system
                         Guardian System Actor



            /Foo

                   Foo                           Bar



        /Foo/A
                                                       A
                   A         C




                         E                                 C
    B
                                                 B

                   D
Name resolution - like a file-system
                             Guardian System Actor



                /Foo

                       Foo                           Bar



            /Foo/A
                                                           A
                       A         C


 /Foo/A/B

                             E                                 C
       B
                                                     B

                       D
Name resolution - like a file-system
                                Guardian System Actor



                   /Foo

                          Foo                           Bar



              /Foo/A
                                                              A
                          A         C


 /Foo/A/B

                                E                                 C
       B
                                                        B

                          D
            /Foo/A/D
2. SEND
2. SEND
• SEND - sends a message to an Actor
2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• Everything happens Reactively
2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• Everything happens Reactively
 -   An Actor is passive until a message is sent to it,
     which triggers something within the Actor
2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• Everything happens Reactively
 -   An Actor is passive until a message is sent to it,
     which triggers something within the Actor

 -   Messages is the Kinetic Energy in an Actor system
2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• Everything happens Reactively
 -   An Actor is passive until a message is sent to it,
     which triggers something within the Actor

 -   Messages is the Kinetic Energy in an Actor system

 -   Actors can have lots of buffered Potential Energy
     but can't do anything with it until it is triggered by
     a message
2. SEND
• SEND - sends a message to an Actor
• Asynchronous and Non-blocking - Fire-forget
• Everything happens Reactively
 -   An Actor is passive until a message is sent to it,
     which triggers something within the Actor

 -   Messages is the Kinetic Energy in an Actor system

 -   Actors can have lots of buffered Potential Energy
     but can't do anything with it until it is triggered by
     a message

• EVERYTHING is asynchronous and lockless
Throughput on a single box




  +50 million messages per second
SEND message
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
greeter.tell(new Greeting("Charlie Parker"));
SEND message
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
greeter.tell(new Greeting("Charlie Parker"));


                    Send the message
Full example
public class Greeting implements Serializable {
   public final String who;
   public Greeting(String who) { this.who = who; }
}

public class GreetingActor extends UntypedActor {
    LoggingAdapter log = Logging.getLogger(getContext().system(), this);

        public void onReceive(Object message) throws Exception {
          if (message instanceof Greeting)
             log.info("Hello {}", ((Greeting) message).who);
          }
    }
}

ActorSystem system = ActorSystem.create("MySystem");
ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
greeter.tell(new Greeting("Charlie Parker"));
Scala version
case class Greeting(who: String)

class GreetingActor extends Actor with ActorLogging {
  def receive = {
    case Greeting(who) => log.info("Hello {}", who)
  }
}

val system = ActorSystem("MySystem")
val greeter = system.actorOf(Props[GreetingActor], name = "greeter")
greeter tell Greeting("Charlie Parker")
Reply
class SomeActor extends UntypedActor {
  void onReceive(Object msg) {
    if (msg instanceof User) {
      User user = (User) msg;
      // reply to sender
      getSender().tell(“Hi ” + user.name);
    }
  }
}
Scala version
class SomeActor extends Actor {
  def receive = {
    case User(name) =>
      // reply to sender
      sender tell (“Hi ” + name)
  }
}
Remote deployment
Just feed the ActorSystem with this configuration


   akka {
     actor {
       provider =    akka.remote.RemoteActorRefProvider
       deployment    {
         /Greeter    {
            remote   =
          }
       }
     }
   }
Remote deployment
Just feed the ActorSystem with this configuration

                                       Configure a Remote Provider
   akka {
     actor {
       provider =    akka.remote.RemoteActorRefProvider
       deployment    {
         /Greeter    {
            remote   =
          }
       }
     }
   }
Remote deployment
     Just feed the ActorSystem with this configuration

                                                  Configure a Remote Provider
           akka {
For the Greeter actor {
              actor
                  provider =    akka.remote.RemoteActorRefProvider
                  deployment    {
                     /Greeter   {
                       remote   =
                     }
                  }
              }
           }
Remote deployment
     Just feed the ActorSystem with this configuration

                                                  Configure a Remote Provider
           akka {
For the Greeter actor {
              actor
                  provider =    akka.remote.RemoteActorRefProvider
                  deployment    {
                     /Greeter   {
                       remote   =
                     }
                  }
    Define Remote Path
              }
           }
Remote deployment
    Just feed the ActorSystem with this configuration

                                             Configure a Remote Provider
           akka {
For the Greeter actor {
              actor
                  provider = akka.remote.RemoteActorRefProvider
                  deployment {
                     /Greeter {
                       remote = akka://
                     }
                  }
    Define Remote Path
              }           Protocol
           }
Remote deployment
    Just feed the ActorSystem with this configuration

                                             Configure a Remote Provider
           akka {
For the Greeter actor {
              actor
                  provider = akka.remote.RemoteActorRefProvider
                  deployment {
                     /Greeter {
                       remote = akka://MySystem
                     }
                  }
    Define Remote Path
              }           Protocol  Actor System
           }
Remote deployment
    Just feed the ActorSystem with this configuration

                                             Configure a Remote Provider
           akka {
For the Greeter actor {
              actor
                  provider = akka.remote.RemoteActorRefProvider
                  deployment {
                     /Greeter {
                       remote = akka://MySystem@machine1
                     }
                  }
    Define Remote Path
              }           Protocol  Actor System Hostname
           }
Remote deployment
     Just feed the ActorSystem with this configuration

                                              Configure a Remote Provider
           akka {
For the Greeter actor {
              actor
                  provider = akka.remote.RemoteActorRefProvider
                  deployment {
                     /Greeter {
                       remote = akka://MySystem@machine1:2552
                     }
                  }
    Define Remote Path
              }           Protocol  Actor System Hostname   Port
           }
Remote deployment
     Just feed the ActorSystem with this configuration

                                              Configure a Remote Provider
           akka {
For the Greeter actor {
              actor
                  provider = akka.remote.RemoteActorRefProvider
                  deployment {
                     /Greeter {
                       remote = akka://MySystem@machine1:2552
                     }
                  }
    Define Remote Path
              }           Protocol  Actor System Hostname   Port
           }



                       Zero code changes
3. BECOME
3. BECOME
• BECOME - dynamically redefines Actor’s behavior
3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
• In a type system analogy it is as if the object changed
  type - changed interface, protocol & implementation
3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
• In a type system analogy it is as if the object changed
  type - changed interface, protocol & implementation
• Will now react differently to the messages it receives
3. BECOME
• BECOME - dynamically redefines Actor’s behavior
• Triggered reactively by receive of message
• In a type system analogy it is as if the object changed
  type - changed interface, protocol & implementation
• Will now react differently to the messages it receives
• Behaviors are stacked & can be pushed and popped
Why would I want to do that?
Why would I want to do that?
• Let a highly contended Actor adaptively transform
  himself into an Actor Pool or a Router
Why would I want to do that?
• Let a highly contended Actor adaptively transform
  himself into an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
Why would I want to do that?
• Let a highly contended Actor adaptively transform
  himself into an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
Why would I want to do that?
• Let a highly contended Actor adaptively transform
  himself into an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
• Spawn up (empty) generic Worker processes that
  can become whatever the Master currently needs
Why would I want to do that?
• Let a highly contended Actor adaptively transform
  himself into an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
• Spawn up (empty) generic Worker processes that
  can become whatever the Master currently needs
• etc. use your imagination
Why would I want to do that?
• Let a highly contended Actor adaptively transform
  himself into an Actor Pool or a Router
• Implement an FSM (Finite State Machine)
• Implement graceful degradation
• Spawn up (empty) generic Worker processes that
  can become whatever the Master currently needs
• etc. use your imagination
• Very useful once you get the used to it
become
context.become(new Procedure[Object]() {
  void apply(Object msg) {
    // new body
    if (msg instanceof NewMessage) {
      NewMessage newMsg = (NewMessage)msg;
      ...
    }
  }
});
Actor context available
                          become
 from within an Actor



         context.become(new Procedure[Object]() {
           void apply(Object msg) {
             // new body
             if (msg instanceof NewMessage) {
               NewMessage newMsg = (NewMessage)msg;
               ...
             }
           }
         });
Scala version
  context become {
    // new body
    case NewMessage =>
      ...
  }
Load Balancing
Routers
val router =
 system.actorOf(
   Props[SomeActor].withRouter(
    RoundRobinRouter(nrOfInstances = 5)))




               Scala API
Router + Resizer
val resizer =
  DefaultResizer(lowerBound = 2, upperBound = 15)

val router =
  system.actorOf(
    Props[ExampleActor1].withRouter(
      RoundRobinRouter(resizer = Some(resizer))))




                   Scala API
Failure management in Java/C/C# etc.
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
   • If this thread blows up you are screwed
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
   • If this thread blows up you are screwed
   • So you need to do all explicit error handling
     WITHIN this single thread
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
   • If this thread blows up you are screwed
   • So you need to do all explicit error handling
     WITHIN this single thread
   • To make things worse - errors do not propagate
     between threads so there is NO WAY OF EVEN
     FINDING OUT that something have failed
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
   • If this thread blows up you are screwed
   • So you need to do all explicit error handling
     WITHIN this single thread
   • To make things worse - errors do not propagate
     between threads so there is NO WAY OF EVEN
     FINDING OUT that something have failed
   • This leads to DEFENSIVE programming with:
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
   • If this thread blows up you are screwed
   • So you need to do all explicit error handling
     WITHIN this single thread
   • To make things worse - errors do not propagate
     between threads so there is NO WAY OF EVEN
     FINDING OUT that something have failed
   • This leads to DEFENSIVE programming with:
      • Error handling TANGLED with business logic
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
   • If this thread blows up you are screwed
   • So you need to do all explicit error handling
     WITHIN this single thread
   • To make things worse - errors do not propagate
     between threads so there is NO WAY OF EVEN
     FINDING OUT that something have failed
   • This leads to DEFENSIVE programming with:
      • Error handling TANGLED with business logic
      • SCATTERED all over the code base
Failure management in Java/C/C# etc.
   • You are given a SINGLE thread of control
   • If this thread blows up you are screwed
   • So you need to do all explicit error handling
     WITHIN this single thread
   • To make things worse - errors do not propagate
     between threads so there is NO WAY OF EVEN
     FINDING OUT that something have failed
   • This leads to DEFENSIVE programming with:
      • Error handling TANGLED with business logic
      • SCATTERED all over the code base

      We can do better than this!!!
4. SUPERVISE
4. SUPERVISE
• SUPERVISE - manage another Actor’s failures
4. SUPERVISE
• SUPERVISE - manage another Actor’s failures
• Error handling in actors is handle by letting Actors
  monitor (supervise) each other for failure
4. SUPERVISE
• SUPERVISE - manage another Actor’s failures
• Error handling in actors is handle by letting Actors
  monitor (supervise) each other for failure
• This means that if an Actor crashes, a notification
  will be sent to his supervisor, who can react upon
  the failure
4. SUPERVISE
• SUPERVISE - manage another Actor’s failures
• Error handling in actors is handle by letting Actors
  monitor (supervise) each other for failure
• This means that if an Actor crashes, a notification
  will be sent to his supervisor, who can react upon
  the failure
• This provides clean separation of processing and
  error handling
...let’s take a
standard OO
  application
Introducing Akka
Which components have
critically important state
            and
 explicit error handling?
Introducing Akka
Fault-tolerant
 onion-layered
 Error Kernel
Error
Kernel
Error
Kernel
Error
Kernel
Error
Kernel
Error
Kernel
Error
Kernel
Node 1   Node 2
Error
Kernel
SUPERVISE Actor
   Every single actor has a
 default supervisor strategy.
 Which is usually sufficient.
  But it can be overridden.
SUPERVISE Actor
                  Every single actor has a
                default supervisor strategy.
                Which is usually sufficient.
                 But it can be overridden.
class Supervisor extends UntypedActor {
  private SupervisorStrategy strategy = new OneForOneStrategy(
    10,
    Duration.parse("1 minute"),
    new Function<Throwable, Directive>() {
      @Override public Directive apply(Throwable t) {
        if (t instanceof ArithmeticException)       return resume();
        else if (t instanceof NullPointerException) return restart();
        else                                        return escalate();
    }
  });

  @Override public SupervisorStrategy supervisorStrategy() {
SUPERVISE Actor
class Supervisor extends UntypedActor {
  private SupervisorStrategy strategy = new OneForOneStrategy(
    10,
    Duration.parse("1 minute"),
    new Function<Throwable, Directive>() {
      @Override public Directive apply(Throwable t) {
        if (t instanceof ArithmeticException)       return resume();
        else if (t instanceof NullPointerException) return restart();
        else                                        return escalate();
    }
  });

    @Override public SupervisorStrategy supervisorStrategy() {
      return strategy;
    }

    ActorRef worker = context.actorOf(new Props(Worker.class));

    public void onReceive(Object message) throws Exception {
      if (message instanceof Integer) worker.forward(message);
    }
}
Scala version
class Supervisor extends Actor {
  override val supervisorStrategy =
                     (maxNrOfRetries = 10, withinTimeRange = 1 minute) {
      case _: ArithmeticException => Resume
      case _: NullPointerException => Restart
      case _: Exception             => Escalate
  }

    val worker = context.actorOf(Props[Worker])

    def receive = {
      case n: Int => worker forward n
    }
}
Scala version
class Supervisor extends Actor {
  override val supervisorStrategy =
    OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
      case _: ArithmeticException => Resume
      case _: NullPointerException => Restart
      case _: Exception             => Escalate
  }

    val worker = context.actorOf(Props[Worker])

    def receive = {
      case n: Int => worker forward n
    }
}
Scala version
class Supervisor extends Actor {
  override val supervisorStrategy =
    AllForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
      case _: ArithmeticException => Resume
      case _: NullPointerException => Restart
      case _: Exception             => Escalate
  }

    val worker = context.actorOf(Props[Worker])

    def receive = {
      case n: Int => worker forward n
    }
}
Manage failure
class Worker extends Actor {
  ...

    override def preRestart(
      reason: Throwable, message: Option[Any]) {
      ... // clean up before restart
    }

    override def postRestart(reason: Throwable) {
      ... // init after restart
    }
}


                   Scala API
This was
Akka 2.x
This was
  Akka 2.x
Well...it’s a start...
...we have much much more
...we have much much more
TestKit           Cluster                      FSM
                                    IO
    HTTP/REST
                         EventBus
 Durable Mailboxes                          Pub/Sub
                            Camel
Microkernel
              TypedActor       SLF4J          AMQP
  ZeroMQ
                     Dataflow             Transactors
Agents
                Spring              Extensions
get it and learn more
       http://akka.io
    http://letitcrash.com
    http://typesafe.com
EOF

Contenu connexe

Tendances

Getting Started with Confluent Schema Registry
Getting Started with Confluent Schema RegistryGetting Started with Confluent Schema Registry
Getting Started with Confluent Schema Registryconfluent
 
Kafka Streams for Java enthusiasts
Kafka Streams for Java enthusiastsKafka Streams for Java enthusiasts
Kafka Streams for Java enthusiastsSlim Baltagi
 
Kafka’s New Control Plane: The Quorum Controller | Colin McCabe, Confluent
Kafka’s New Control Plane: The Quorum Controller | Colin McCabe, ConfluentKafka’s New Control Plane: The Quorum Controller | Colin McCabe, Confluent
Kafka’s New Control Plane: The Quorum Controller | Colin McCabe, ConfluentHostedbyConfluent
 
Introduction to Apache Kafka
Introduction to Apache KafkaIntroduction to Apache Kafka
Introduction to Apache KafkaJeff Holoman
 
Introduction to Apache Camel
Introduction to Apache CamelIntroduction to Apache Camel
Introduction to Apache CamelClaus Ibsen
 
Java Concurrency Gotchas
Java Concurrency GotchasJava Concurrency Gotchas
Java Concurrency GotchasAlex Miller
 
A visual introduction to Apache Kafka
A visual introduction to Apache KafkaA visual introduction to Apache Kafka
A visual introduction to Apache KafkaPaul Brebner
 
[오픈소스컨설팅] 스카우터 사용자 가이드 2020
[오픈소스컨설팅] 스카우터 사용자 가이드 2020[오픈소스컨설팅] 스카우터 사용자 가이드 2020
[오픈소스컨설팅] 스카우터 사용자 가이드 2020Ji-Woong Choi
 
The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...
The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...
The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...Redis Labs
 
Twitter의 snowflake 소개 및 활용
Twitter의 snowflake 소개 및 활용Twitter의 snowflake 소개 및 활용
Twitter의 snowflake 소개 및 활용흥배 최
 
Producer Performance Tuning for Apache Kafka
Producer Performance Tuning for Apache KafkaProducer Performance Tuning for Apache Kafka
Producer Performance Tuning for Apache KafkaJiangjie Qin
 
Disaster Recovery Plans for Apache Kafka
Disaster Recovery Plans for Apache KafkaDisaster Recovery Plans for Apache Kafka
Disaster Recovery Plans for Apache Kafkaconfluent
 
Running Kafka On Kubernetes With Strimzi For Real-Time Streaming Applications
Running Kafka On Kubernetes With Strimzi For Real-Time Streaming ApplicationsRunning Kafka On Kubernetes With Strimzi For Real-Time Streaming Applications
Running Kafka On Kubernetes With Strimzi For Real-Time Streaming ApplicationsLightbend
 
Introduction to Kafka Streams
Introduction to Kafka StreamsIntroduction to Kafka Streams
Introduction to Kafka StreamsGuozhang Wang
 
Redis vs Infinispan | DevNation Tech Talk
Redis vs Infinispan | DevNation Tech TalkRedis vs Infinispan | DevNation Tech Talk
Redis vs Infinispan | DevNation Tech TalkRed Hat Developers
 
[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용
[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용
[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용Jihyung Song
 

Tendances (20)

Getting Started with Confluent Schema Registry
Getting Started with Confluent Schema RegistryGetting Started with Confluent Schema Registry
Getting Started with Confluent Schema Registry
 
Apache Kafka
Apache KafkaApache Kafka
Apache Kafka
 
Kafka Streams for Java enthusiasts
Kafka Streams for Java enthusiastsKafka Streams for Java enthusiasts
Kafka Streams for Java enthusiasts
 
Kafka’s New Control Plane: The Quorum Controller | Colin McCabe, Confluent
Kafka’s New Control Plane: The Quorum Controller | Colin McCabe, ConfluentKafka’s New Control Plane: The Quorum Controller | Colin McCabe, Confluent
Kafka’s New Control Plane: The Quorum Controller | Colin McCabe, Confluent
 
Introduction to Apache Kafka
Introduction to Apache KafkaIntroduction to Apache Kafka
Introduction to Apache Kafka
 
Introduction to Apache Camel
Introduction to Apache CamelIntroduction to Apache Camel
Introduction to Apache Camel
 
Building Netty Servers
Building Netty ServersBuilding Netty Servers
Building Netty Servers
 
Java Concurrency Gotchas
Java Concurrency GotchasJava Concurrency Gotchas
Java Concurrency Gotchas
 
A visual introduction to Apache Kafka
A visual introduction to Apache KafkaA visual introduction to Apache Kafka
A visual introduction to Apache Kafka
 
[오픈소스컨설팅] 스카우터 사용자 가이드 2020
[오픈소스컨설팅] 스카우터 사용자 가이드 2020[오픈소스컨설팅] 스카우터 사용자 가이드 2020
[오픈소스컨설팅] 스카우터 사용자 가이드 2020
 
Kafka 101
Kafka 101Kafka 101
Kafka 101
 
The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...
The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...
The Happy Marriage of Redis and Protobuf by Scott Haines of Twilio - Redis Da...
 
Twitter의 snowflake 소개 및 활용
Twitter의 snowflake 소개 및 활용Twitter의 snowflake 소개 및 활용
Twitter의 snowflake 소개 및 활용
 
Producer Performance Tuning for Apache Kafka
Producer Performance Tuning for Apache KafkaProducer Performance Tuning for Apache Kafka
Producer Performance Tuning for Apache Kafka
 
Disaster Recovery Plans for Apache Kafka
Disaster Recovery Plans for Apache KafkaDisaster Recovery Plans for Apache Kafka
Disaster Recovery Plans for Apache Kafka
 
Java NIO.2
Java NIO.2Java NIO.2
Java NIO.2
 
Running Kafka On Kubernetes With Strimzi For Real-Time Streaming Applications
Running Kafka On Kubernetes With Strimzi For Real-Time Streaming ApplicationsRunning Kafka On Kubernetes With Strimzi For Real-Time Streaming Applications
Running Kafka On Kubernetes With Strimzi For Real-Time Streaming Applications
 
Introduction to Kafka Streams
Introduction to Kafka StreamsIntroduction to Kafka Streams
Introduction to Kafka Streams
 
Redis vs Infinispan | DevNation Tech Talk
Redis vs Infinispan | DevNation Tech TalkRedis vs Infinispan | DevNation Tech Talk
Redis vs Infinispan | DevNation Tech Talk
 
[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용
[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용
[ Pycon Korea 2017 ] Infrastructure as Code를위한 Ansible 활용
 

En vedette

Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...
Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...
Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...Legacy Typesafe (now Lightbend)
 
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...Lightbend
 
Advanced akka features
Advanced akka featuresAdvanced akka features
Advanced akka featuresGrzegorz Duda
 
Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...
Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...
Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...Jonas Bonér
 
Reactive Stream Processing with Akka Streams
Reactive Stream Processing with Akka StreamsReactive Stream Processing with Akka Streams
Reactive Stream Processing with Akka StreamsKonrad Malawski
 
Akka in Production - ScalaDays 2015
Akka in Production - ScalaDays 2015Akka in Production - ScalaDays 2015
Akka in Production - ScalaDays 2015Evan Chan
 
High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...
High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...
High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...Chris Fregly
 

En vedette (8)

Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...
Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...
Reactive Revealed Part 3 of 3: Resiliency, Failures vs Errors, Isolation, Del...
 
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...
Akka Revealed: A JVM Architect's Journey From Resilient Actors To Scalable Cl...
 
Zen of Akka
Zen of AkkaZen of Akka
Zen of Akka
 
Advanced akka features
Advanced akka featuresAdvanced akka features
Advanced akka features
 
Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...
Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...
Akka: Simpler Scalability, Fault-Tolerance, Concurrency & Remoting through Ac...
 
Reactive Stream Processing with Akka Streams
Reactive Stream Processing with Akka StreamsReactive Stream Processing with Akka Streams
Reactive Stream Processing with Akka Streams
 
Akka in Production - ScalaDays 2015
Akka in Production - ScalaDays 2015Akka in Production - ScalaDays 2015
Akka in Production - ScalaDays 2015
 
High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...
High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...
High Performance TensorFlow in Production - Big Data Spain - Madrid - Nov 15 ...
 

Similaire à Introducing Akka

Scaling software with akka
Scaling software with akkaScaling software with akka
Scaling software with akkascalaconfjp
 
Build Cloud Applications with Akka and Heroku
Build Cloud Applications with Akka and HerokuBuild Cloud Applications with Akka and Heroku
Build Cloud Applications with Akka and HerokuSalesforce Developers
 
Test driven infrastructure development (2 - puppetconf 2013 edition)
Test driven infrastructure development (2 - puppetconf 2013 edition)Test driven infrastructure development (2 - puppetconf 2013 edition)
Test driven infrastructure development (2 - puppetconf 2013 edition)Tomas Doran
 
The Ember.js Framework - Everything You Need To Know
The Ember.js Framework - Everything You Need To KnowThe Ember.js Framework - Everything You Need To Know
The Ember.js Framework - Everything You Need To KnowAll Things Open
 
Орхан Гасимов: "Reactive Applications in Java with Akka"
Орхан Гасимов: "Reactive Applications in Java with Akka"Орхан Гасимов: "Reactive Applications in Java with Akka"
Орхан Гасимов: "Reactive Applications in Java with Akka"Anna Shymchenko
 
Typesafe Reactive Platform: Monitoring 1.0, Commercial features and more
Typesafe Reactive Platform: Monitoring 1.0, Commercial features and moreTypesafe Reactive Platform: Monitoring 1.0, Commercial features and more
Typesafe Reactive Platform: Monitoring 1.0, Commercial features and moreLegacy Typesafe (now Lightbend)
 
Learn you some Ansible for great good!
Learn you some Ansible for great good!Learn you some Ansible for great good!
Learn you some Ansible for great good!David Lapsley
 
Clojure Conj 2014 - Paradigms of core.async - Julian Gamble
Clojure Conj 2014 - Paradigms of core.async - Julian GambleClojure Conj 2014 - Paradigms of core.async - Julian Gamble
Clojure Conj 2014 - Paradigms of core.async - Julian GambleJulian Gamble
 
Akka london scala_user_group
Akka london scala_user_groupAkka london scala_user_group
Akka london scala_user_groupSkills Matter
 
OpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander Dibbo
OpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander DibboOpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander Dibbo
OpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander DibboOpenNebula Project
 
Modelling Microservices at Spotify - Petter Mahlen
Modelling Microservices at Spotify - Petter MahlenModelling Microservices at Spotify - Petter Mahlen
Modelling Microservices at Spotify - Petter MahlenJ On The Beach
 
Reactive Web-Applications @ LambdaDays
Reactive Web-Applications @ LambdaDaysReactive Web-Applications @ LambdaDays
Reactive Web-Applications @ LambdaDaysManuel Bernhardt
 
Reactive applications and Akka intro used in the Madrid Scala Meetup
Reactive applications and Akka intro used in the Madrid Scala MeetupReactive applications and Akka intro used in the Madrid Scala Meetup
Reactive applications and Akka intro used in the Madrid Scala MeetupMiguel Pastor
 
CQRS Evolved - CQRS + Akka.NET
CQRS Evolved - CQRS + Akka.NETCQRS Evolved - CQRS + Akka.NET
CQRS Evolved - CQRS + Akka.NETDavid Hoerster
 
Operational Visibiliy and Analytics - BU Seminar
Operational Visibiliy and Analytics - BU SeminarOperational Visibiliy and Analytics - BU Seminar
Operational Visibiliy and Analytics - BU SeminarCanturk Isci
 
High performance network programming on the jvm oscon 2012
High performance network programming on the jvm   oscon 2012 High performance network programming on the jvm   oscon 2012
High performance network programming on the jvm oscon 2012 Erik Onnen
 
Akka Microservices Architecture And Design
Akka Microservices Architecture And DesignAkka Microservices Architecture And Design
Akka Microservices Architecture And DesignYaroslav Tkachenko
 

Similaire à Introducing Akka (20)

Scaling software with akka
Scaling software with akkaScaling software with akka
Scaling software with akka
 
Build Cloud Applications with Akka and Heroku
Build Cloud Applications with Akka and HerokuBuild Cloud Applications with Akka and Heroku
Build Cloud Applications with Akka and Heroku
 
Test driven infrastructure development (2 - puppetconf 2013 edition)
Test driven infrastructure development (2 - puppetconf 2013 edition)Test driven infrastructure development (2 - puppetconf 2013 edition)
Test driven infrastructure development (2 - puppetconf 2013 edition)
 
The Ember.js Framework - Everything You Need To Know
The Ember.js Framework - Everything You Need To KnowThe Ember.js Framework - Everything You Need To Know
The Ember.js Framework - Everything You Need To Know
 
Орхан Гасимов: "Reactive Applications in Java with Akka"
Орхан Гасимов: "Reactive Applications in Java with Akka"Орхан Гасимов: "Reactive Applications in Java with Akka"
Орхан Гасимов: "Reactive Applications in Java with Akka"
 
Typesafe Reactive Platform: Monitoring 1.0, Commercial features and more
Typesafe Reactive Platform: Monitoring 1.0, Commercial features and moreTypesafe Reactive Platform: Monitoring 1.0, Commercial features and more
Typesafe Reactive Platform: Monitoring 1.0, Commercial features and more
 
Clustersoftware
ClustersoftwareClustersoftware
Clustersoftware
 
Learn you some Ansible for great good!
Learn you some Ansible for great good!Learn you some Ansible for great good!
Learn you some Ansible for great good!
 
Clojure Conj 2014 - Paradigms of core.async - Julian Gamble
Clojure Conj 2014 - Paradigms of core.async - Julian GambleClojure Conj 2014 - Paradigms of core.async - Julian Gamble
Clojure Conj 2014 - Paradigms of core.async - Julian Gamble
 
Akka london scala_user_group
Akka london scala_user_groupAkka london scala_user_group
Akka london scala_user_group
 
OpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander Dibbo
OpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander DibboOpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander Dibbo
OpenNebulaConf2015 1.07 Cloud for Scientific Computing @ STFC - Alexander Dibbo
 
Modelling Microservices at Spotify - Petter Mahlen
Modelling Microservices at Spotify - Petter MahlenModelling Microservices at Spotify - Petter Mahlen
Modelling Microservices at Spotify - Petter Mahlen
 
Reactive Web-Applications @ LambdaDays
Reactive Web-Applications @ LambdaDaysReactive Web-Applications @ LambdaDays
Reactive Web-Applications @ LambdaDays
 
Reactive applications and Akka intro used in the Madrid Scala Meetup
Reactive applications and Akka intro used in the Madrid Scala MeetupReactive applications and Akka intro used in the Madrid Scala Meetup
Reactive applications and Akka intro used in the Madrid Scala Meetup
 
Scale up your thinking
Scale up your thinkingScale up your thinking
Scale up your thinking
 
CQRS Evolved - CQRS + Akka.NET
CQRS Evolved - CQRS + Akka.NETCQRS Evolved - CQRS + Akka.NET
CQRS Evolved - CQRS + Akka.NET
 
Operational Visibiliy and Analytics - BU Seminar
Operational Visibiliy and Analytics - BU SeminarOperational Visibiliy and Analytics - BU Seminar
Operational Visibiliy and Analytics - BU Seminar
 
Performance testing material
Performance testing materialPerformance testing material
Performance testing material
 
High performance network programming on the jvm oscon 2012
High performance network programming on the jvm   oscon 2012 High performance network programming on the jvm   oscon 2012
High performance network programming on the jvm oscon 2012
 
Akka Microservices Architecture And Design
Akka Microservices Architecture And DesignAkka Microservices Architecture And Design
Akka Microservices Architecture And Design
 

Plus de Jonas Bonér

We are drowning in complexity—can we do better?
We are drowning in complexity—can we do better?We are drowning in complexity—can we do better?
We are drowning in complexity—can we do better?Jonas Bonér
 
Kalix: Tackling the The Cloud to Edge Continuum
Kalix: Tackling the The Cloud to Edge ContinuumKalix: Tackling the The Cloud to Edge Continuum
Kalix: Tackling the The Cloud to Edge ContinuumJonas Bonér
 
The Reactive Principles: Design Principles For Cloud Native Applications
The Reactive Principles: Design Principles For Cloud Native ApplicationsThe Reactive Principles: Design Principles For Cloud Native Applications
The Reactive Principles: Design Principles For Cloud Native ApplicationsJonas Bonér
 
Cloudstate—Towards Stateful Serverless
Cloudstate—Towards Stateful ServerlessCloudstate—Towards Stateful Serverless
Cloudstate—Towards Stateful ServerlessJonas Bonér
 
Designing Events-first Microservices
Designing Events-first MicroservicesDesigning Events-first Microservices
Designing Events-first MicroservicesJonas Bonér
 
How Events Are Reshaping Modern Systems
How Events Are Reshaping Modern SystemsHow Events Are Reshaping Modern Systems
How Events Are Reshaping Modern SystemsJonas Bonér
 
Reactive Microsystems: The Evolution of Microservices at Scale
Reactive Microsystems: The Evolution of Microservices at ScaleReactive Microsystems: The Evolution of Microservices at Scale
Reactive Microsystems: The Evolution of Microservices at ScaleJonas Bonér
 
From Microliths To Microsystems
From Microliths To MicrosystemsFrom Microliths To Microsystems
From Microliths To MicrosystemsJonas Bonér
 
Without Resilience, Nothing Else Matters
Without Resilience, Nothing Else MattersWithout Resilience, Nothing Else Matters
Without Resilience, Nothing Else MattersJonas Bonér
 
Life Beyond the Illusion of Present
Life Beyond the Illusion of PresentLife Beyond the Illusion of Present
Life Beyond the Illusion of PresentJonas Bonér
 
Go Reactive: Building Responsive, Resilient, Elastic & Message-Driven Systems
Go Reactive: Building Responsive, Resilient, Elastic & Message-Driven SystemsGo Reactive: Building Responsive, Resilient, Elastic & Message-Driven Systems
Go Reactive: Building Responsive, Resilient, Elastic & Message-Driven SystemsJonas Bonér
 
Reactive Supply To Changing Demand
Reactive Supply To Changing DemandReactive Supply To Changing Demand
Reactive Supply To Changing DemandJonas Bonér
 
Building Reactive Systems with Akka (in Java 8 or Scala)
Building Reactive Systems with Akka (in Java 8 or Scala)Building Reactive Systems with Akka (in Java 8 or Scala)
Building Reactive Systems with Akka (in Java 8 or Scala)Jonas Bonér
 
Go Reactive: Event-Driven, Scalable, Resilient & Responsive Systems
Go Reactive: Event-Driven, Scalable, Resilient & Responsive SystemsGo Reactive: Event-Driven, Scalable, Resilient & Responsive Systems
Go Reactive: Event-Driven, Scalable, Resilient & Responsive SystemsJonas Bonér
 
Building Scalable, Highly Concurrent & Fault Tolerant Systems - Lessons Learned
Building Scalable, Highly Concurrent & Fault Tolerant Systems -  Lessons LearnedBuilding Scalable, Highly Concurrent & Fault Tolerant Systems -  Lessons Learned
Building Scalable, Highly Concurrent & Fault Tolerant Systems - Lessons LearnedJonas Bonér
 
Event Driven-Architecture from a Scalability perspective
Event Driven-Architecture from a Scalability perspectiveEvent Driven-Architecture from a Scalability perspective
Event Driven-Architecture from a Scalability perspectiveJonas Bonér
 
Scalability, Availability & Stability Patterns
Scalability, Availability & Stability PatternsScalability, Availability & Stability Patterns
Scalability, Availability & Stability PatternsJonas Bonér
 
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVM
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVMState: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVM
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVMJonas Bonér
 
Pragmatic Real-World Scala (short version)
Pragmatic Real-World Scala (short version)Pragmatic Real-World Scala (short version)
Pragmatic Real-World Scala (short version)Jonas Bonér
 

Plus de Jonas Bonér (19)

We are drowning in complexity—can we do better?
We are drowning in complexity—can we do better?We are drowning in complexity—can we do better?
We are drowning in complexity—can we do better?
 
Kalix: Tackling the The Cloud to Edge Continuum
Kalix: Tackling the The Cloud to Edge ContinuumKalix: Tackling the The Cloud to Edge Continuum
Kalix: Tackling the The Cloud to Edge Continuum
 
The Reactive Principles: Design Principles For Cloud Native Applications
The Reactive Principles: Design Principles For Cloud Native ApplicationsThe Reactive Principles: Design Principles For Cloud Native Applications
The Reactive Principles: Design Principles For Cloud Native Applications
 
Cloudstate—Towards Stateful Serverless
Cloudstate—Towards Stateful ServerlessCloudstate—Towards Stateful Serverless
Cloudstate—Towards Stateful Serverless
 
Designing Events-first Microservices
Designing Events-first MicroservicesDesigning Events-first Microservices
Designing Events-first Microservices
 
How Events Are Reshaping Modern Systems
How Events Are Reshaping Modern SystemsHow Events Are Reshaping Modern Systems
How Events Are Reshaping Modern Systems
 
Reactive Microsystems: The Evolution of Microservices at Scale
Reactive Microsystems: The Evolution of Microservices at ScaleReactive Microsystems: The Evolution of Microservices at Scale
Reactive Microsystems: The Evolution of Microservices at Scale
 
From Microliths To Microsystems
From Microliths To MicrosystemsFrom Microliths To Microsystems
From Microliths To Microsystems
 
Without Resilience, Nothing Else Matters
Without Resilience, Nothing Else MattersWithout Resilience, Nothing Else Matters
Without Resilience, Nothing Else Matters
 
Life Beyond the Illusion of Present
Life Beyond the Illusion of PresentLife Beyond the Illusion of Present
Life Beyond the Illusion of Present
 
Go Reactive: Building Responsive, Resilient, Elastic & Message-Driven Systems
Go Reactive: Building Responsive, Resilient, Elastic & Message-Driven SystemsGo Reactive: Building Responsive, Resilient, Elastic & Message-Driven Systems
Go Reactive: Building Responsive, Resilient, Elastic & Message-Driven Systems
 
Reactive Supply To Changing Demand
Reactive Supply To Changing DemandReactive Supply To Changing Demand
Reactive Supply To Changing Demand
 
Building Reactive Systems with Akka (in Java 8 or Scala)
Building Reactive Systems with Akka (in Java 8 or Scala)Building Reactive Systems with Akka (in Java 8 or Scala)
Building Reactive Systems with Akka (in Java 8 or Scala)
 
Go Reactive: Event-Driven, Scalable, Resilient & Responsive Systems
Go Reactive: Event-Driven, Scalable, Resilient & Responsive SystemsGo Reactive: Event-Driven, Scalable, Resilient & Responsive Systems
Go Reactive: Event-Driven, Scalable, Resilient & Responsive Systems
 
Building Scalable, Highly Concurrent & Fault Tolerant Systems - Lessons Learned
Building Scalable, Highly Concurrent & Fault Tolerant Systems -  Lessons LearnedBuilding Scalable, Highly Concurrent & Fault Tolerant Systems -  Lessons Learned
Building Scalable, Highly Concurrent & Fault Tolerant Systems - Lessons Learned
 
Event Driven-Architecture from a Scalability perspective
Event Driven-Architecture from a Scalability perspectiveEvent Driven-Architecture from a Scalability perspective
Event Driven-Architecture from a Scalability perspective
 
Scalability, Availability & Stability Patterns
Scalability, Availability & Stability PatternsScalability, Availability & Stability Patterns
Scalability, Availability & Stability Patterns
 
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVM
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVMState: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVM
State: You're Doing It Wrong - Alternative Concurrency Paradigms For The JVM
 
Pragmatic Real-World Scala (short version)
Pragmatic Real-World Scala (short version)Pragmatic Real-World Scala (short version)
Pragmatic Real-World Scala (short version)
 

Dernier

UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7DianaGray10
 
Videogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfVideogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfinfogdgmi
 
UiPath Solutions Management Preview - Northern CA Chapter - March 22.pdf
UiPath Solutions Management Preview - Northern CA Chapter - March 22.pdfUiPath Solutions Management Preview - Northern CA Chapter - March 22.pdf
UiPath Solutions Management Preview - Northern CA Chapter - March 22.pdfDianaGray10
 
20230202 - Introduction to tis-py
20230202 - Introduction to tis-py20230202 - Introduction to tis-py
20230202 - Introduction to tis-pyJamie (Taka) Wang
 
Building AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptxBuilding AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptxUdaiappa Ramachandran
 
9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding Team9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding TeamAdam Moalla
 
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostKubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostMatt Ray
 
COMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a WebsiteCOMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a Websitedgelyza
 
Cybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptxCybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptxGDSC PJATK
 
UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...
UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...
UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...UbiTrack UK
 
Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024D Cloud Solutions
 
Bird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystemBird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystemAsko Soukka
 
How Accurate are Carbon Emissions Projections?
How Accurate are Carbon Emissions Projections?How Accurate are Carbon Emissions Projections?
How Accurate are Carbon Emissions Projections?IES VE
 
OpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability AdventureOpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability AdventureEric D. Schabell
 
The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...
The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...
The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...Aggregage
 
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1DianaGray10
 
AI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just MinutesAI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just MinutesMd Hossain Ali
 
Introduction to Matsuo Laboratory (ENG).pptx
Introduction to Matsuo Laboratory (ENG).pptxIntroduction to Matsuo Laboratory (ENG).pptx
Introduction to Matsuo Laboratory (ENG).pptxMatsuo Lab
 
Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )Brian Pichman
 
VoIP Service and Marketing using Odoo and Asterisk PBX
VoIP Service and Marketing using Odoo and Asterisk PBXVoIP Service and Marketing using Odoo and Asterisk PBX
VoIP Service and Marketing using Odoo and Asterisk PBXTarek Kalaji
 

Dernier (20)

UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7UiPath Studio Web workshop series - Day 7
UiPath Studio Web workshop series - Day 7
 
Videogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdfVideogame localization & technology_ how to enhance the power of translation.pdf
Videogame localization & technology_ how to enhance the power of translation.pdf
 
UiPath Solutions Management Preview - Northern CA Chapter - March 22.pdf
UiPath Solutions Management Preview - Northern CA Chapter - March 22.pdfUiPath Solutions Management Preview - Northern CA Chapter - March 22.pdf
UiPath Solutions Management Preview - Northern CA Chapter - March 22.pdf
 
20230202 - Introduction to tis-py
20230202 - Introduction to tis-py20230202 - Introduction to tis-py
20230202 - Introduction to tis-py
 
Building AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptxBuilding AI-Driven Apps Using Semantic Kernel.pptx
Building AI-Driven Apps Using Semantic Kernel.pptx
 
9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding Team9 Steps For Building Winning Founding Team
9 Steps For Building Winning Founding Team
 
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCostKubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
KubeConEU24-Monitoring Kubernetes and Cloud Spend with OpenCost
 
COMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a WebsiteCOMPUTER 10 Lesson 8 - Building a Website
COMPUTER 10 Lesson 8 - Building a Website
 
Cybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptxCybersecurity Workshop #1.pptx
Cybersecurity Workshop #1.pptx
 
UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...
UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...
UWB Technology for Enhanced Indoor and Outdoor Positioning in Physiological M...
 
Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024Artificial Intelligence & SEO Trends for 2024
Artificial Intelligence & SEO Trends for 2024
 
Bird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystemBird eye's view on Camunda open source ecosystem
Bird eye's view on Camunda open source ecosystem
 
How Accurate are Carbon Emissions Projections?
How Accurate are Carbon Emissions Projections?How Accurate are Carbon Emissions Projections?
How Accurate are Carbon Emissions Projections?
 
OpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability AdventureOpenShift Commons Paris - Choose Your Own Observability Adventure
OpenShift Commons Paris - Choose Your Own Observability Adventure
 
The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...
The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...
The Data Metaverse: Unpacking the Roles, Use Cases, and Tech Trends in Data a...
 
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1UiPath Platform: The Backend Engine Powering Your Automation - Session 1
UiPath Platform: The Backend Engine Powering Your Automation - Session 1
 
AI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just MinutesAI Fame Rush Review – Virtual Influencer Creation In Just Minutes
AI Fame Rush Review – Virtual Influencer Creation In Just Minutes
 
Introduction to Matsuo Laboratory (ENG).pptx
Introduction to Matsuo Laboratory (ENG).pptxIntroduction to Matsuo Laboratory (ENG).pptx
Introduction to Matsuo Laboratory (ENG).pptx
 
Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )Building Your Own AI Instance (TBLC AI )
Building Your Own AI Instance (TBLC AI )
 
VoIP Service and Marketing using Odoo and Asterisk PBX
VoIP Service and Marketing using Odoo and Asterisk PBXVoIP Service and Marketing using Odoo and Asterisk PBX
VoIP Service and Marketing using Odoo and Asterisk PBX
 

Introducing Akka

  • 1. Introducing Jonas Bonér CTO Typesafe
  • 3. Introducing Akka (Áhkká) The name comes from the goddess in the Sami (native swedes) mythology that represented all the wisdom and beauty in the world. It is also the name of a beautiful mountain in Laponia in the north part of Sweden
  • 5. Vision Simpler Concurrency Scalability Fault-tolerance
  • 6. Vision ...with a single unified Programming Model Managed Runtime Open Source Distribution
  • 8. Scale UP & Scale OUT
  • 9. Program at a Higher Level
  • 10. Program at a Higher Level
  • 11. Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc.
  • 12. Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc. • Low level concurrency plumbing BECOMES SIMPLE WORKFLOW - you only think about how messages flow in the system
  • 13. Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc. • Low level concurrency plumbing BECOMES SIMPLE WORKFLOW - you only think about how messages flow in the system • You get high CPU utilization, low latency, high throughput and scalability - FOR FREE as part of the model
  • 14. Program at a Higher Level • Never think in terms of shared state, state visibility, threads, locks, concurrent collections, thread notifications etc. • Low level concurrency plumbing BECOMES SIMPLE WORKFLOW - you only think about how messages flow in the system • You get high CPU utilization, low latency, high throughput and scalability - FOR FREE as part of the model • Proven and superior model for detecting and recovering from errors
  • 17. Distributable by Design • Actors are location transparent & distributable by design
  • 18. Distributable by Design • Actors are location transparent & distributable by design • Scale UP and OUT for free as part of the model
  • 19. Distributable by Design • Actors are location transparent & distributable by design • Scale UP and OUT for free as part of the model • You get the PERFECT FABRIC for the CLOUD
  • 20. Distributable by Design • Actors are location transparent & distributable by design • Scale UP and OUT for free as part of the model • You get the PERFECT FABRIC for the CLOUD - elastic & dynamic
  • 21. Distributable by Design • Actors are location transparent & distributable by design • Scale UP and OUT for free as part of the model • You get the PERFECT FABRIC for the CLOUD - elastic & dynamic - fault-tolerant & self-healing
  • 22. Distributable by Design • Actors are location transparent & distributable by design • Scale UP and OUT for free as part of the model • You get the PERFECT FABRIC for the CLOUD - elastic & dynamic - fault-tolerant & self-healing - adaptive load-balancing, cluster rebalancing & actor migration
  • 23. Distributable by Design • Actors are location transparent & distributable by design • Scale UP and OUT for free as part of the model • You get the PERFECT FABRIC for the CLOUD - elastic & dynamic - fault-tolerant & self-healing - adaptive load-balancing, cluster rebalancing & actor migration - build extremely loosely coupled and dynamic systems that can change and adapt at runtime
  • 24. Selection of Akka Production Users
  • 28. Let’s use Actors How can we achieve this?
  • 29. What is an Actor?
  • 30. What is an Actor?
  • 31. What is an Actor? • Akka's unit of code organization is called an Actor
  • 32. What is an Actor? • Akka's unit of code organization is called an Actor • Actors helps you create concurrent, scalable and fault-tolerant applications
  • 33. What is an Actor? • Akka's unit of code organization is called an Actor • Actors helps you create concurrent, scalable and fault-tolerant applications • Like Java EE servlets and session beans, Actors is a model for organizing your code that keeps many “policy decisions” separate from the business logic
  • 34. What is an Actor? • Akka's unit of code organization is called an Actor • Actors helps you create concurrent, scalable and fault-tolerant applications • Like Java EE servlets and session beans, Actors is a model for organizing your code that keeps many “policy decisions” separate from the business logic • Actors may be new to many in the Java community, but they are a tried-and-true concept (Hewitt 1973) used for many years in telecom systems with 9 nines uptime
  • 36. Actors can be seen as Virtual Machines (nodes) in Cloud Computing
  • 41. ...that manages their own memory and behavior
  • 42. ...that manages their own memory and behavior
  • 44. Communicates with asynchronous non-blocking messages
  • 45. Communicates with asynchronous non-blocking messages
  • 47. Elastic - grow and shrink on demand
  • 48. Elastic - grow and shrink on demand
  • 49. Elastic - grow and shrink on demand
  • 50. Elastic - grow and shrink on demand
  • 52. Hot deploy - change behavior at runtime
  • 53. Hot deploy - change behavior at runtime
  • 54. Now - if we replace with Actor EVERYTHING will STILL HOLD for both LOCAL and DISTRIBUTED Actors
  • 55. What can I use Actors for?
  • 56. What can I use Actors for? In different scenarios, an Actor may be an alternative to:
  • 57. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread
  • 58. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component
  • 59. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener
  • 60. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service
  • 61. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or pool
  • 62. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or pool - a Java EE Session Bean or Message-Driven Bean
  • 63. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or pool - a Java EE Session Bean or Message-Driven Bean - an out-of-process service
  • 64. What can I use Actors for? In different scenarios, an Actor may be an alternative to: - a thread - an object instance or component - a callback or listener - a singleton or service - a router, load-balancer or pool - a Java EE Session Bean or Message-Driven Bean - an out-of-process service - a Finite State Machine (FSM)
  • 65. So, what is the Actor Model?
  • 66. Carl Hewitt’s definition http://bit.ly/hewitt-on-actors
  • 67. Carl Hewitt’s definition - The fundamental unit of computation that embodies: http://bit.ly/hewitt-on-actors
  • 68. Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing http://bit.ly/hewitt-on-actors
  • 69. Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage http://bit.ly/hewitt-on-actors
  • 70. Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication http://bit.ly/hewitt-on-actors
  • 71. Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: http://bit.ly/hewitt-on-actors
  • 72. Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: - Create new Actors http://bit.ly/hewitt-on-actors
  • 73. Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: - Create new Actors - Send messages to Actors it knows http://bit.ly/hewitt-on-actors
  • 74. Carl Hewitt’s definition - The fundamental unit of computation that embodies: - Processing - Storage - Communication - 3 axioms - When an Actor receives a message it can: - Create new Actors - Send messages to Actors it knows - Designate how it should handle the next message it receives http://bit.ly/hewitt-on-actors
  • 75. 4 core Actor operations 0. DEFINE 1. CREATE 2. SEND 3. BECOME 4. SUPERVISE
  • 76. 0. DEFINE public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } }
  • 77. 0. DEFINE Define the message(s) the Actor should be able to respond to public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } }
  • 78. 0. DEFINE Define the message(s) the Actor should be able to respond to public class Greeting implements Serializable { public final String who; Define the Actor class public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } }
  • 79. 0. DEFINE Define the message(s) the Actor should be able to respond to public class Greeting implements Serializable { public final String who; Define the Actor class public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } Define the Actor’s behavior }
  • 80. Scala version case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello {}", who) } }
  • 81. 1. CREATE • CREATE - creates a new instance of an Actor • Extremely lightweight (2.7 Million per Gb RAM) • Very strong encapsulation - encapsulates: -  state -  behavior -  message queue • State & behavior is indistinguishable from each other • Only way to observe state is by sending an actor a message and see how it reacts
  • 82. CREATE Actor public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
  • 83. CREATE Actor public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } Create an Actor system } } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
  • 84. CREATE Actor public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } Create an Actor system } Actor configuration } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
  • 85. CREATE Actor public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } Create an Actor system } Actor configuration } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter"); Give it a name
  • 86. CREATE Actor public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } Create an Actor system } Actor configuration } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter"); Create the Actor Give it a name
  • 87. CREATE Actor public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } Create an Actor system } Actor configuration } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter"); Create the Actor You get an ActorRef back Give it a name
  • 88. Actors can form hierarchies Guardian System Actor
  • 89. Actors can form hierarchies Guardian System Actor system.actorOf(Props[Foo], “Foo”)
  • 90. Actors can form hierarchies Guardian System Actor Foo system.actorOf(Props[Foo], “Foo”)
  • 91. Actors can form hierarchies Guardian System Actor Foo context.actorOf(Props[A], “A”)
  • 92. Actors can form hierarchies Guardian System Actor Foo A context.actorOf(Props[A], “A”)
  • 93. Actors can form hierarchies Guardian System Actor Foo Bar A A C E C B B D
  • 94. Name resolution - like a file-system Guardian System Actor Foo Bar A A C E C B B D
  • 95. Name resolution - like a file-system Guardian System Actor /Foo Foo Bar A A C E C B B D
  • 96. Name resolution - like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A A C E C B B D
  • 97. Name resolution - like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A A C /Foo/A/B E C B B D
  • 98. Name resolution - like a file-system Guardian System Actor /Foo Foo Bar /Foo/A A A C /Foo/A/B E C B B D /Foo/A/D
  • 100. 2. SEND • SEND - sends a message to an Actor
  • 101. 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget
  • 102. 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • Everything happens Reactively
  • 103. 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • Everything happens Reactively - An Actor is passive until a message is sent to it, which triggers something within the Actor
  • 104. 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • Everything happens Reactively - An Actor is passive until a message is sent to it, which triggers something within the Actor - Messages is the Kinetic Energy in an Actor system
  • 105. 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • Everything happens Reactively - An Actor is passive until a message is sent to it, which triggers something within the Actor - Messages is the Kinetic Energy in an Actor system - Actors can have lots of buffered Potential Energy but can't do anything with it until it is triggered by a message
  • 106. 2. SEND • SEND - sends a message to an Actor • Asynchronous and Non-blocking - Fire-forget • Everything happens Reactively - An Actor is passive until a message is sent to it, which triggers something within the Actor - Messages is the Kinetic Energy in an Actor system - Actors can have lots of buffered Potential Energy but can't do anything with it until it is triggered by a message • EVERYTHING is asynchronous and lockless
  • 107. Throughput on a single box +50 million messages per second
  • 108. SEND message public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter"); greeter.tell(new Greeting("Charlie Parker"));
  • 109. SEND message public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter"); greeter.tell(new Greeting("Charlie Parker")); Send the message
  • 110. Full example public class Greeting implements Serializable { public final String who; public Greeting(String who) { this.who = who; } } public class GreetingActor extends UntypedActor { LoggingAdapter log = Logging.getLogger(getContext().system(), this); public void onReceive(Object message) throws Exception { if (message instanceof Greeting) log.info("Hello {}", ((Greeting) message).who); } } } ActorSystem system = ActorSystem.create("MySystem"); ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter"); greeter.tell(new Greeting("Charlie Parker"));
  • 111. Scala version case class Greeting(who: String) class GreetingActor extends Actor with ActorLogging { def receive = { case Greeting(who) => log.info("Hello {}", who) } } val system = ActorSystem("MySystem") val greeter = system.actorOf(Props[GreetingActor], name = "greeter") greeter tell Greeting("Charlie Parker")
  • 112. Reply class SomeActor extends UntypedActor { void onReceive(Object msg) { if (msg instanceof User) { User user = (User) msg; // reply to sender getSender().tell(“Hi ” + user.name); } } }
  • 113. Scala version class SomeActor extends Actor { def receive = { case User(name) => // reply to sender sender tell (“Hi ” + name) } }
  • 114. Remote deployment Just feed the ActorSystem with this configuration akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = } } } }
  • 115. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { actor { provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = } } } }
  • 116. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = } } } }
  • 117. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = } } Define Remote Path } }
  • 118. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = akka:// } } Define Remote Path } Protocol }
  • 119. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = akka://MySystem } } Define Remote Path } Protocol Actor System }
  • 120. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = akka://MySystem@machine1 } } Define Remote Path } Protocol Actor System Hostname }
  • 121. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = akka://MySystem@machine1:2552 } } Define Remote Path } Protocol Actor System Hostname Port }
  • 122. Remote deployment Just feed the ActorSystem with this configuration Configure a Remote Provider akka { For the Greeter actor { actor provider = akka.remote.RemoteActorRefProvider deployment { /Greeter { remote = akka://MySystem@machine1:2552 } } Define Remote Path } Protocol Actor System Hostname Port } Zero code changes
  • 124. 3. BECOME • BECOME - dynamically redefines Actor’s behavior
  • 125. 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message
  • 126. 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message • In a type system analogy it is as if the object changed type - changed interface, protocol & implementation
  • 127. 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message • In a type system analogy it is as if the object changed type - changed interface, protocol & implementation • Will now react differently to the messages it receives
  • 128. 3. BECOME • BECOME - dynamically redefines Actor’s behavior • Triggered reactively by receive of message • In a type system analogy it is as if the object changed type - changed interface, protocol & implementation • Will now react differently to the messages it receives • Behaviors are stacked & can be pushed and popped
  • 129. Why would I want to do that?
  • 130. Why would I want to do that? • Let a highly contended Actor adaptively transform himself into an Actor Pool or a Router
  • 131. Why would I want to do that? • Let a highly contended Actor adaptively transform himself into an Actor Pool or a Router • Implement an FSM (Finite State Machine)
  • 132. Why would I want to do that? • Let a highly contended Actor adaptively transform himself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation
  • 133. Why would I want to do that? • Let a highly contended Actor adaptively transform himself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation • Spawn up (empty) generic Worker processes that can become whatever the Master currently needs
  • 134. Why would I want to do that? • Let a highly contended Actor adaptively transform himself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation • Spawn up (empty) generic Worker processes that can become whatever the Master currently needs • etc. use your imagination
  • 135. Why would I want to do that? • Let a highly contended Actor adaptively transform himself into an Actor Pool or a Router • Implement an FSM (Finite State Machine) • Implement graceful degradation • Spawn up (empty) generic Worker processes that can become whatever the Master currently needs • etc. use your imagination • Very useful once you get the used to it
  • 136. become context.become(new Procedure[Object]() { void apply(Object msg) { // new body if (msg instanceof NewMessage) { NewMessage newMsg = (NewMessage)msg; ... } } });
  • 137. Actor context available become from within an Actor context.become(new Procedure[Object]() { void apply(Object msg) { // new body if (msg instanceof NewMessage) { NewMessage newMsg = (NewMessage)msg; ... } } });
  • 138. Scala version context become { // new body case NewMessage => ... }
  • 140. Routers val router = system.actorOf( Props[SomeActor].withRouter( RoundRobinRouter(nrOfInstances = 5))) Scala API
  • 141. Router + Resizer val resizer = DefaultResizer(lowerBound = 2, upperBound = 15) val router = system.actorOf( Props[ExampleActor1].withRouter( RoundRobinRouter(resizer = Some(resizer)))) Scala API
  • 142. Failure management in Java/C/C# etc.
  • 143. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control
  • 144. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed
  • 145. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread
  • 146. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed
  • 147. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with:
  • 148. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with: • Error handling TANGLED with business logic
  • 149. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with: • Error handling TANGLED with business logic • SCATTERED all over the code base
  • 150. Failure management in Java/C/C# etc. • You are given a SINGLE thread of control • If this thread blows up you are screwed • So you need to do all explicit error handling WITHIN this single thread • To make things worse - errors do not propagate between threads so there is NO WAY OF EVEN FINDING OUT that something have failed • This leads to DEFENSIVE programming with: • Error handling TANGLED with business logic • SCATTERED all over the code base We can do better than this!!!
  • 152. 4. SUPERVISE • SUPERVISE - manage another Actor’s failures
  • 153. 4. SUPERVISE • SUPERVISE - manage another Actor’s failures • Error handling in actors is handle by letting Actors monitor (supervise) each other for failure
  • 154. 4. SUPERVISE • SUPERVISE - manage another Actor’s failures • Error handling in actors is handle by letting Actors monitor (supervise) each other for failure • This means that if an Actor crashes, a notification will be sent to his supervisor, who can react upon the failure
  • 155. 4. SUPERVISE • SUPERVISE - manage another Actor’s failures • Error handling in actors is handle by letting Actors monitor (supervise) each other for failure • This means that if an Actor crashes, a notification will be sent to his supervisor, who can react upon the failure • This provides clean separation of processing and error handling
  • 156. ...let’s take a standard OO application
  • 158. Which components have critically important state and explicit error handling?
  • 167. Node 1 Node 2 Error Kernel
  • 168. SUPERVISE Actor Every single actor has a default supervisor strategy. Which is usually sufficient. But it can be overridden.
  • 169. SUPERVISE Actor Every single actor has a default supervisor strategy. Which is usually sufficient. But it can be overridden. class Supervisor extends UntypedActor { private SupervisorStrategy strategy = new OneForOneStrategy( 10, Duration.parse("1 minute"), new Function<Throwable, Directive>() { @Override public Directive apply(Throwable t) { if (t instanceof ArithmeticException) return resume(); else if (t instanceof NullPointerException) return restart(); else return escalate(); } }); @Override public SupervisorStrategy supervisorStrategy() {
  • 170. SUPERVISE Actor class Supervisor extends UntypedActor { private SupervisorStrategy strategy = new OneForOneStrategy( 10, Duration.parse("1 minute"), new Function<Throwable, Directive>() { @Override public Directive apply(Throwable t) { if (t instanceof ArithmeticException) return resume(); else if (t instanceof NullPointerException) return restart(); else return escalate(); } }); @Override public SupervisorStrategy supervisorStrategy() { return strategy; } ActorRef worker = context.actorOf(new Props(Worker.class)); public void onReceive(Object message) throws Exception { if (message instanceof Integer) worker.forward(message); } }
  • 171. Scala version class Supervisor extends Actor { override val supervisorStrategy = (maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: Exception => Escalate } val worker = context.actorOf(Props[Worker]) def receive = { case n: Int => worker forward n } }
  • 172. Scala version class Supervisor extends Actor { override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: Exception => Escalate } val worker = context.actorOf(Props[Worker]) def receive = { case n: Int => worker forward n } }
  • 173. Scala version class Supervisor extends Actor { override val supervisorStrategy = AllForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) { case _: ArithmeticException => Resume case _: NullPointerException => Restart case _: Exception => Escalate } val worker = context.actorOf(Props[Worker]) def receive = { case n: Int => worker forward n } }
  • 174. Manage failure class Worker extends Actor { ... override def preRestart( reason: Throwable, message: Option[Any]) { ... // clean up before restart } override def postRestart(reason: Throwable) { ... // init after restart } } Scala API
  • 176. This was Akka 2.x Well...it’s a start...
  • 177. ...we have much much more
  • 178. ...we have much much more TestKit Cluster FSM IO HTTP/REST EventBus Durable Mailboxes Pub/Sub Camel Microkernel TypedActor SLF4J AMQP ZeroMQ Dataflow Transactors Agents Spring Extensions
  • 179. get it and learn more http://akka.io http://letitcrash.com http://typesafe.com
  • 180. EOF