• Hard to debug

Bugs hard to reproduce, harder to fix

• Hard to optimize

Locks create contention, which can slow performance.

1. public class Greeting implements Serializable {
2. public final String who;
3. public Greeting(String who) { this.who = who; }
4. }
5.  
6. public class GreetingActor extends UntypedActor {
7. LoggingAdapter log = Logging.getLogger(getContext().system(), this);
8.  
9. public void onReceive(Object message) throws Exception {
10. if (message instanceof Greeting)
11. log.info("Hello " + ((Greeting) message).who);
12. }
13. }
14.  
15. ActorSystem system = ActorSystem.create("MySystem");
16. ActorRef greeter = system.actorOf(new Props(GreetingActor.class), "greeter");
17. greeter.tell(new Greeting("Charlie Parker"));

• Conceptually simple
• Can be used as a library
• Not intrusive
• Can use remote actors

• Cannot call new for actors

public class StatelessActorDemo {
    public static void main(String[] args) throws InterruptedException {
        final MyStatelessActor actor = new MyStatelessActor();
        actor.start();
        actor.send("Hello");
        actor.sendAndWait(10);
        actor.sendAndContinue(10.0, new MessagingRunnable<String>() {
            @Override protected void doRun(final String s) {
                System.out.println("Received a reply " + s);
            }
        });
    }
}
        
class MyStatelessActor extends DynamicDispatchActor {
    public void onMessage(final String msg) {
        System.out.println("Received " + msg);
        replyIfExists("Thank you");
    }
        
    public void onMessage(final Integer msg) {
        System.out.println("Received a number " + msg);
        replyIfExists("Thank you");
    }
        
    public void onMessage(final Object msg) {
        System.out.println("Received an object " + msg);
        replyIfExists("Thank you");
    }
}
    

• Very Simple to use
• Integrates cleanly
• Not intrusive
• Clean code for receiving messages
• Easy to reply to messages

• No support for remote actors
• No built-in routing
• There is not as much support
• Groovy is not very performant

Fiber fiber = new ThreadFiber();
fiber.start();
final CountDownLatch latch = new CountDownLatch(2);
Runnable toRun = new Runnable(){
   public void run(){
      latch.countDown();
   }
};
//enqueue runnable for execution
fiber.execute(toRun);
//repeat to trigger latch a 2nd time
fiber.execute(toRun);

latch.await(10, TimeUnit.SECONDS);

//shutdown thread
fiber.dispose();

• Fast
• Open Source
• No external dependencies
• Explicit control over channels and threads

• Syntax to use it is very obtrussive
• Programmer must become well acquainted with library
• Sometimes awkward to program