Ruby goes to @elise_huard FrozenRails 2011 

Context 

Concurrency is Hard 

No content

Shared and Mutable State 

Why Bother? 

Actors 

Actor Model (1973) 

No Global State Actors Partial Order of Execution 

No content

Objects were meant to be Actors 

spawn send receive 

Sleeping Barber 

Barber BarberShop The universe customer X customers waiting wake up sleeping/cutting customers? customer X no 

Ruby 

Rubinius Actors @mentalguy 

Celluloid @bascule 

Text class Barber include Celluloid::Actor attr_accessor :status def initialize(shop) @shop = shop end def cut_customer(name) puts " cutting customer #{name}" sleep(rand(5)) accident = rand(2) if accident puts " finished cutting #{name}" else puts " *** whoops, chopped #{name}'s head off ***" end shop.customer_leaves! end (...) end 

Text class Shop include Celluloid::Actor def initialize @barber = Barber.new(self) @chairs = [] puts "lights on ..." end def waiting_line @chairs.size end def new_customer(name) puts " customer arriving: #{name}" if waiting_line > 3 puts "*** sorry, #{name}, no room ***" else @chairs << name @barber.cut_customer!(name) end end def customer_leaves @chairs.shift end end 

Text shop = Shop.new ['jack', 'john', 'henry', 'tom', 'bob'].each do |customer| shop.new_customer!(customer) end shop.report 

CRuby 

Cheat on Ruby 

Erlang 

%% shop %% barber_shop() -> io:format("lights on ... ~n"), ShopPid = self(), BarberPid = spawn(fun() -> barber(ShopPid) end), barber_shop_in_business(BarberPid, []). barber_shop_in_business(BarberPid, CustomersInChairs) -> receive {cut, Customer} -> % pop customer from list when hair is being cut remove_customer(BarberPid, CustomersInChairs, Customer); barbercheck -> respond_to_barber(BarberPid, CustomersInChairs); Customer -> io:format("~p arrives~n",[Customer]), % should check the number of customers waiting first % if all full: customer turned away add_customer_if_available(BarberPid, CustomersInChairs, Customer) end. 

Text %% barber %% barber(ShopPid) -> ShopPid ! barbercheck, receive wakeup -> barber(ShopPid); {customer, Customer} -> cut(ShopPid, Customer), barber(ShopPid) end. cut(ShopPid, Name) -> io:format("cutting ~p~n", [Name]), % take customer -> can be removed from waiting chairs ShopPid ! {cut, Name}, timer:sleep(random:uniform(10000)), io:format("finished cutting: ~p~n", [Name]). 

Text scenario() -> ShopPid = start_shop(), % send customers to the shop ShopPid ! 'john', ShopPid ! 'joe', timer:sleep(20000), ShopPid ! 'kevin', ShopPid ! 'richard', main_end. 

Text 

Elixir 

Text object Shop def initialize shop_pid = Process.current barber_pid = Process.spawn -> Barber.loop(shop_pid) @('barber_pid: barber_pid, 'shop_pid: shop_pid) end def loop(customers_in_chairs) IO.puts "shop loop #{customers_in_chairs}" receive match {'cut, customer} if customers_in_chairs.include?(customer) loop(customers_in_chairs.delete(customer)) else loop(customers_in_chairs) end match 'barbercheck IO.puts "barber checking ..." respond_to_barber(customers_in_chairs) match {'customer, customer} IO.puts("new customer #{customer}") add_customer(customers_in_chairs, customer) end end (...) 

Text module Barber def loop(shop_pid) shop_pid <- 'barbercheck receive match 'wakeup IO.puts "wakeup" loop(shop_pid) match {'customer, customer} cut_hair(shop_pid, customer) loop(shop_pid) end end def cut_hair(shop_pid, customer) IO.puts "cutting customer #{customer}" shop_pid <- {'cut, customer} IO.puts "finished cutting customer #{customer}" end end 

Text pid = Process.spawn -> Shop.new.loop([]) IO.puts pid pid <- {'customer, "jack"} pid <- {'customer, "bob"} 

Scala 

No content

JRuby 

Text class Conductor < Akka::UntypedActor def self.spawn actor = Akka::Actors.actor_of { new } actor.set_dispatcher(Akka::Dispatchers.newThreadBasedDispatcher(actor)) actor.start end def onReceive(msg) case msg when "go" puts 'play score' play_guitar play_drum when "done drumming" play_end_drum when "done guitar" play_guitar else puts "msg: #{msg}" end end def play_end_drum puts "play end drum" end_drum = EndDrum.spawn end_drum.send_one_way("play", context) end (...) end 

Text class Musician < Akka::UntypedActor include Music def self.spawn actor = Akka::Actors.actor_of { new } actor.set_dispatcher(Akka::Dispatchers.newThreadBasedDispatche r(actor)) actor.start end def onReceive(msg) case msg when "play" @conductor = context.sender.get @conductor = Akka::Actors.registry.actor_for(@conductor.uuid).get play(@conductor) else puts "msg: #{msg}" end end end 

Text class Guitar < Musician def play(conductor) play_mp3("Guitar_Loop_Riff.mp3") conductor.send_one_way("done guitar") end end 

Text http://vimeo.com/29528327 

Caveat 

easy to understand real encapsulation highly decentralized 

No content

only when parallel components livelocks - deadlocks still possible different programming style 

Concurrency Primitives 

Epilogue 

Time to control shared state? 

Better Concurrency Primitives in stdlib? 

No content

Kiitos Kuunteluun! Speaker @elise_huard Conference Frozen Rails 2011 Sponsor Forward Pictures By The Waterfront Vertigo Casablanca Tarzan Wizard of Oz Some like it hot King Kong Citizen Kane Documentation http://www.delicious.com/elisehuard/concurrency