Since the dawn of concurrency research, there have been two camps: shared everything, and shared nothing. Most modern applications use threads for concurrency, a shared everything architecture.
Actors, however, use a shared nothing architecture where lightweight processes communicate with each other using message passing. Actors can change their state, create a new Actor, send a message to any Actor it has the Address of, and wait for a specific kind of message to arrive in it's mailbox.
Actors: What, Why, and How
What Is an Actor?
- An Actor Is a Process
- An Actor Can Change It's Own State
- An Actor Can Create Another Actor and Get it's Address
- An Actor Can Send a Message To Any Addresses It Knows
- An Actor Can Wait for a Specific Message to Arrive in It's Mailbox
Why Use Actors?
Only an Actor Can Change It's Own State
Each Actor Is a Process, Simplifying Control Flow
Message Passing Is Easy to Distribute
- Most Exceptional Conditions Occur When Waiting for a Message
- Isolates Error Handling Code
- Makes It Easier to Build Fault Tolerant Distributed Systems
How Are Actors Implemented in Python Actors?
Use Eventlet's Green Threads to Implement Processes
- This Doesn't Provide Real Isolation
- But Python Doesn't Provide Private Either
Copy Messages As They Are Sent Between Actors
This Provides Good Enough Isolation
- We Can Serialize/Deserialize With simplejson To Copy
- This Also Makes Messages Network Safe
- Other More Optimized Implementations Possible
A WSGI Application Exposes Actors to Network
- Uses a Simple REST Protocol
- PUT Spawns an Actor
- POST Sends a Message to an Actor
- GET Gets the Current State of the Actor
- DELETE Sends a Killed Exception to the Actor
Problem: Imported Modules Leak State Between Actors
- Possibility: Keep a Unique Copy of sys.modules for Every Actor
- Possibility: Seal Modules in Wrapper Object Preventing Modification
- Reality: Just Write Code that Doesn't Abuse Global Module State