Upgrade to Pro — share decks privately, control downloads, hide ads and more …

RubyConf.ph 2014 - ZOMGSCALE! With Celluloid & ...

RubyConf.ph 2014 - ZOMGSCALE! With Celluloid & JRuby

Ben Lovell

March 29, 2014
Tweet

More Decks by Ben Lovell

Other Decks in Programming

Transcript

  1. ?

  2. GIL

  3. GIL

  4. a concurrent object oriented programming framework which lets you build

    multithreaded programs out of concurrent objects just as easily as you build sequential programs out of regular objects
  5. 1 class Actor! 2 attr_reader :counter! 3 ! 4 def

    initialize! 5 @counter = 0! 6 @mutex = Mutex.new! 7 end! 8 ! 9 def increment! 10 @mutex.synchronize do! 11 @counter += 1! 12 end! 13 end! 14 end!
  6. 1 require "celluloid"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 attr_reader :counter! 6 ! 7 def initialize! 8 @counter = 0! 9 end! 10 ! 11 def increment! 12 @counter += 1! 13 end! 14 end!
  7. 1 require "celluloid"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 end! 6 ! 7 actor = Actor.new! 8 actor.inspect! 9 #=> <Celluloid::ActorProxy(Actor:0x3feaecbb38e0)>! 10 ! 11 Thread.main! 12 #=> <Thread:0x007f86290b8ce8 run>! 13 ! 14 actor.thread! 15 #=> <Thread:0x007f862ad27a78 sleep>!
  8. 1 module Celluloid! 2 module ClassMethods! 3 # Create a

    new actor! 4 def new(*args, &block)! 5 proxy = Actor.new(allocate, actor_options).proxy! 6 proxy._send_(:initialize, *args, &block)! 7 proxy! 8 end! 9 #...! 10 end! 11 #...! 12 end!
  9. 1 class Actor! 2 # Wrap the given subject with

    an Actor! 3 def initialize(subject, options = {})! 4 @subject = subject! 5 @mailbox = options[:mailbox] || Mailbox.new! 6 @running = true! 7 ! 8 @thread = ThreadHandle.new(:actor) do! 9 setup_thread! 10 run! 11 end! 12 #...! 13 end! 14 #...! 15 end!
  10. 1 class Actor! 2 def run! 3 #...! 4 while

    @running! 5 if message = @mailbox.receive(timeout_interval)! 6 handle_message message! 7 else! 8 # No message indicates a timeout! 9 @timers.fire! 10 @receivers.fire_timers! 11 end! 12 end! 13 #...! 14 shutdown! 15 end! 16 end!
  11. 1 require "celluloid"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 ! 6 def compute_all_the_things! 7 sleep 2! 8 puts "42"! 9 end! 10 end! 11 ! 12 actor = Actor.new! 13 actor.compute_all_the_things! 14 puts "done!"! ! #=> 42! #=> done!! blocking
  12. 1 require "celluloid"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 ! 6 def compute_all_the_things! 7 sleep 2! 8 puts "42"! 9 end! 10 end! 11 ! 12 actor = Actor.new! 13 actor.async.compute_all_the_things! 14 puts "done!"! 15 ! 16 #=> done!! 17 #=> 42! returns immediately
  13. 1 require "celluloid"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 ! 6 def compute_all_the_things! 7 sleep 2! 8 "42"! 9 end! 10 end! 11 ! 12 actor = Actor.new! 13 future = actor.future.compute_all_the_things! 14 puts "done!"! 15 puts future.value! 16 ! 17 #=> done!! 18 #=> 42! returns immediately blocks until a value is yielded
  14. 1 require "celluloid"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 ! 6 def compute_all_the_things! 7 sleep 2! 8 puts "42"! 9 end! 10 end! 11 ! 12 actor = Actor.new! 13 Celluloid::Actor[:foo] = actor! 14 ! 15 actor.inspect! 16 #=> <Celluloid::ActorProxy(Actor:0x3feb3ec11308)>! 17 Celluloid::Actor[:foo].inspect! 18 #=> <Celluloid::ActorProxy(Actor:0x3feb3ec11308)>!
  15. 1 require "celluloid/autostart"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 ! 6 def compute_all_the_things! 7 puts "42"! 8 end! 9 ! 10 def zomg_crash! 11 raise "derp!"! 12 end! 13 end! 14 ! 15 supervisor = Actor.supervise_as :foo! 16 ! 17 begin! 18 Celluloid::Actor[:foo].zomg_crash! 19 rescue! 20 puts "whoops"! 21 end! 22 ! 23 Celluloid::Actor[:foo].compute_all_the_things! 24 ! 25 #=> whoops! 26 #=> 42! crash the actor fresh actor take care of me!
  16. 1 require "celluloid"! 2 ! 3 class Actor! 4 include

    Celluloid! 5 ! 6 def compute_all_the_things! 7 sleep 1! 8 puts "42"! 9 end! 10 end! 11 ! 12 pool = Actor.pool! 13 ! 14 4.times { pool.compute_all_the_things }! 15 ! 16 #=> 42! 17 #=> 42 and so on...! size*cores load up the workers
  17. unlike certain other evented I/O systems which limit you to

    a single event loop per process Celluloid::IO lets you make as many actors as you want system resources permitting
  18. a distributed extension to celluloid which provides distributed and concurrent

    objects for ruby that are both robust and fault-tolerant
  19. a fast non-blocking and evented web server. Thanks to celluloid,

    Reel works great for multithreaded applications and provides traditional multithreaded blocking IO support too.