Scala concurrency patterns with Actors
summary
Explains how Scala actor systems actually work: actors isolate mutable state and communicate via mailboxes, dispatchers and routers; an actor instance costs about 300 bytes and mailboxes can be bounded, prioritized or persistent. Covers supervisor strategies (four recovery actions), delivery semantics (at-least-once vs at-most-once), dispatcher choices (thread-pool, pinned-thread, deterministic) and tradeoffs when building a real system — cites a Samsung image-search case that tolerates partial loss rather than full transactional guarantees.
AI-written summary · about
chapters (23)
- 0:00Introduction to Scala Actors
- 3:07Problems with shared mutable state
- 5:43History of the Actor model
- 7:14Core Actor model rules
- 11:24Actor message processing
- 15:50Creating Actors safely
- 17:44Supervisors and fault tolerance
- 19:11Actor routers and strategies
- 23:00Dispatcher types explained
- 25:28Monitoring and debugging Actors
- 26:47Message delivery guarantees
- 28:48When to use Actors
- 33:12Real-world use case at Samsung
- 35:48Demo setup and expectations
- 37:13Learning resources and tools
- 41:35Distributed Actors and clustering
- 45:05Actors as interfaces
- 46:38Event sourcing with Actors
- 48:25Distributed Actors challenges
- 50:08Benefits of Actors in one JVM
- 51:32Non-blocking vs blocking patterns
- 52:27Best practices and key takeaways
- 53:15Q&A and closing remarks
related talks
32mAdopting Actors... an epic tale of loss and learning
45mSo you want to be an actor? Lessons from implementing the actor model
32mMaximizing Throughput and Scalability for Akka Streams
44m10 Lessons From Implementing The Actor Model
37mBeyond Fault Tolerance
22mActing Lessons for Scala Engineers with Akka and ZIO
17mYou asked for it, you got it: type safe Actors
54mIntroduction to the Actor Model