Ruby goes to Hollywood

Ruby
goes to
Ruby,

@elise_huard Rubykaigi 2011

“Shared and Mutable State”

“Actor Model” (1973)
(1973)

“No Global State”
” ”

“Actors”
” ”

“Partial Order of Execution”
” ”

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

“Rubinius Actors”
@mentalguy

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)) Text
accident = rand(2)
if accident
puts " finished cutting #{name}"
else
puts " *** whoops, chopped #{name}'s head off ***"
end
shop.customer_leaves!
end
(...)
end

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) Text
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

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

%% 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.

%% barber %%
barber(ShopPid) ->
ShopPid ! barbercheck,
receive
wakeup ->
barber(ShopPid);
{customer, Customer} ->
cut(ShopPid, Customer),
barber(ShopPid)
end. Text
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]).

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

http://vimeo.com/26560141

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 Text
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
(...)
end

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) Text
end
end

def cut_hair(shop_pid, customer)
IO.puts "cutting customer #{customer}"
shop_pid <- {'cut, customer}
IO.puts "ﬁnished cutting customer #{customer}"
end
end

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

class BarberShop extends Actor {
var barber: ActorRef = null
var customersInChairs = List[Customer]()

override def preStart() {
barber = Actor.actorOf(new Barber(self)).start()
}

def receive = {
case Customer(name) =>
if (customersInChairs.length >= 3) {
Text
println("sorry, no room for " + name)
} else {
customersInChairs = customersInChairs :+ Customer(name)
barber ! WakeUp
}
case Cut(name) =>
customersInChairs = customersInChairs.tail
case BarberCheck =>
// send first customer
barber ! customersInChairs.head
}
}

class Barber(val shop: ActorRef) extends Actor {
def cut(name: String) = {
shop ! Cut(name)
}
def receive = {
case WakeUp =>
shop ! BarberCheck
Text
case Customer(name) =>
cut(name)
shop ! BarberCheck
}
}

package sleepingBarber

import akka.actor.{Actor, ActorRef, ActorRegistry}
import Actor._
import akka.actor.Actor.actorOf

/* messages classes */
sealed trait BarberMessage
case class Customer(name: String) extends BarberMessage
case class Cut(name: String) extends BarberMessage
case class BarberCheck() extends BarberMessage
Text
case class NoCustomers() extends BarberMessage
case class WakeUp() extends BarberMessage

object SleepingBarber {
def main(args: Array[String]) : Unit = {
val barberShop = Actor.actorOf[BarberShop].start()
barberShop ! Customer("John")
barberShop ! Customer("Jack")
barberShop ! Customer("Arthur")
Actor.registry.shutdownAll
}
}

“easy to understand”
“ ”

“real encapsulation”
” ”

“highly decentralized”
” ”

“clear separation of parallel components”
“ ”

“livelocks - deadlocks still possible”
“ - ”

“Time to control shared state?”
shared state

“Better Concurrency Primitives
in stdlib?”

!

Speaker Pictures

Sherlock Jr (1924)
@elise_huard Safety Last (1923)
A Woman of Affairs (1928)
Mysteries of a Barbershop (1923)
Translation The Doll (1919)
Intolerance (1926)
Metropolis (1927)
He Who Gets Slapped (1924)
Conference
Laughing Gravy (1931)
Documentation
Ruby Kaigi 2011
http://www.delicious.com/elisehuard/concurrency
Sponsor

Forward

The End

@ @@elise_huard
Translation:

Ruby goes to Hollywood

Recommandé

Recommandé

Contenu connexe

Plus de ehuard

Plus de ehuard (11)

Dernier

Dernier (20)

Ruby goes to Hollywood