Ruby acting up A look at how Celluloid implements the actor
 model for concurrency in Ruby. 

encapsulated
 state message message 

Actor /ˈaktə/ noun 1. a participant in an action or process. 

Actor /ˈaktə/ noun 1. a participant in an action or process. 2. a process with an inbox for receiving messages. 

Thread basics Thread.new do loop do # do something interesting end end 

Concurrency & Parallelism 

Thread basics Thread.new do loop do # do something interesting end end 

Starting and stopping @running = true Thread.new do while @running do # do something interesting end end 

Queues require 'thread' @running = true @queue = Queue.new Thread.new do while @running do message = @queue.pop # do something interesting with message end end 

Actor object class Actor def initialize @running = true @queue = Queue.new @thread = Thread.new do while @running do process_message( @queue.pop ) end end end def stop @running = false end private def process_message(msg) # do stuff here end end 

Thread safety class Actor def initialize @counter = 0 end def process_message(msg) @counter += 1 end end 

Thread safety class Actor def initialize @counter = 0 end def process_message(msg) @counter = (@counter + 1) end end 

Mutex def initialize @mutex = Mutex.new end def process_message(msg) @mutex.synchronize do # ... end end 

Queueing messages class Greeter def greet(name) puts "Hello, #{name}!" end end greeter = Greeter.new @queue << [:greet, "John"] greeter.send *@queue.pop 

Actor delegates to object class Actor def initialize(target) @target = target @thread = Thread.new do process_inbox end end def process_inbox while @running process_message *@queue.pop end end def process_message(func, *args) @mutex.synchronize do target.public_send(
 func, *args ) end end end 

Actor send_async class Actor def send_async(*args) @queue << args end end class Greeter def greet(name) puts "Hello, #{name}!" end end greeter = Greeter.new actor = Actor.new(greeter) actor.send_async( :greet, 'John' ) 

Celluloid actor mixin module Celluloid def self.included(base) base.extend ClassMethods end module ClassMethods def new(*args) Actor.new(super) end end class Actor def method_missing(*args) target .public_send(*args) end end end 

Celluloid async proxy module Celluloid class Actor def initialize(target) @proxy = AsyncProxy.new(self) end def async @proxy end end class AsyncProxy def initialize(actor) @actor = actor end def method_missing(*args) @actor.send_async(*args) end end end 

Celluloid example class Pinger URL = "http://www.google.com/webmasters/tools/ping?sitemap=%s" include Celluloid def ping(sitemap_url) Net::HTTP.get(URL % sitemap_url) end end pinger = Pinger.new url = 'http://arjanvandergaag.nl/sitemap.xml' pinger.ping(url) # => wait... 200 OK" pinger.async.ping(url) # => nil 

Celluloid futures pinger.ping(url) # => "200 OK" future = pinger.future.ping(url) # => # future.value # => "200 OK" 

Ruby promises with Whenner pinger.ping.then do |on| on.done do |value| puts "Done with status #{value}" end on.fail do |value| puts "Something bad happened!" end end Whenner.when(pinger.ping, ponger.pong).done do |results| results.each do |status| puts status end end 

Actors are objects handling messages in a separate thread. 

Find out more • Celluloid • Celluloid::IO • Concurrent Programming with Celluloid (Tony Arcieri, MountainWest RubyConf 2012) • Sidekiq • RubyTapas • Whenner