Question

I’ve read akka documentation and can’t produce clean understanding of thread interaction while using akka. Docs may omit this thing as obvious but it is not so obvious for me.

All akka actors seemed to be run in same thread they are called. I see actors as co-procedures that just had own stack reset each time receive called.

You may perform a huge chain of actors switching in straight line. Each receive perform small non-blocking operation and force another receive to work further. There is no event loop, that can handle messages outside of the actor system.

I’d like to catch a request from other thread, perform control operations, and wait for another message.

There are some use cases that outline my needs.

1. There is thread that constantly polling data from some sources. Once data matches pattern it invokes event-driven handler based on actors. Logical controller makes a decision and passes it workers. There should be two persistent thread. One threads works constantly on polling and another works asynchronously to control it work. You should not let akka actors to first thread since they broke polling periods and first thread should not block actors so they need another thread.

2. There is some kind of two-side board game. One side has a controller thread that schedules calculation time works interacts with board server and etcetera. Other thread is a heavy calculating thread that loops over different variants and could not be written in akka since it has blocking nature

I aware of existing akka futures, but they represent a working task that run once fired and shutting down after performing their goal. The futures are well combined with akka actors, but can not express looped working threads.

Akka actor system incorporates different kinds of network event loops. You may use its built-in remote actor system or well known 0mq protocol. But using network for thread interactions seems like overdoing for me.

What is the supposed way to glue non-akka thread with akka one? Should I wrote a couple of special procedures to perform message passing in thread-safe way?

Answer 1

If you need polling, then the polling thread should just turn whatever is polled into a message and fire it off to an actor.

I find it more useful to use an Actor with a receiveTimeout to do non-blocking polling at an interval, and when there’s something that gets polled, it will publish it to some other actor, or perhaps even its ActorSystems’ EventStream, for true pub-sub action.