concurrent-ruby 0.3.0 → 0.3.1.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b89f9ac58f382096ac50f90e256d3cf68dd1ce3d
-  data.tar.gz: 6bf065b9e23f67c79f9e7d3c524c6de780c78c38
+  metadata.gz: 86c7da12ad6b46036abb100e98a1450eda80fbb1
+  data.tar.gz: 43e1758062fd717a6e4a0c690890ef8149aa7b9e
 SHA512:
-  metadata.gz: 2cadb5b8eb1e3ddebf91c375d6266a5f57e09b01d83222d2f06aee5312e286a9aa36d146aedf9d6acdf27d088821fc18a5e7fa14836e3645eebeacf8ba8ca095
-  data.tar.gz: c2f0f34b9956391c4c63b3761de2bd871b3233b36a35d7ed16419b0c9b7385f4f1be884522cdd8c9d151cc86836bb1b3fec1872ca57410a12f4676f98c90399b
+  metadata.gz: 1d46489016358e9138bf0a627617ef780d2feb8e9a0d2b1f2a4ac1aa25ff8ec94dab7c72ad5c62743adc8d6ce36b0b119d80c3aa57724685aa33788e541f2aea
+  data.tar.gz: b482b8b50ee0217bb0ed13dcb8d3c91f58984d660f91240484d867f72e7583b87fcde09558beb1349ecff39ba88e9d9ddc44863cb91f14a74d4109cf1ebcac05

data/README.md

@@ -6,6 +6,18 @@ Inspired by Erlang, Clojure, Go, JavaScript, actors, and classic concurrency pat
 If you find this gem useful you should check out my [functional-ruby](https://github.com/jdantonio/functional-ruby)
 gem, too. This gem uses several of the tools in that gem.
 
+## Conference Presentations
+
+I've given several conference presentations on concurrent programming with this gem.
+Check them out:
+
+* ["Advanced Concurrent Programming in Ruby"](http://rubyconf.org/program#jerry-dantonio)
+  at [RubyConf 2013](http://rubyconf.org/) used [this](https://github.com/jdantonio/concurrent-ruby-presentation) version of the presentation
+* ["Advanced Multithreading in Ruby"](http://cascadiaruby.com/#advanced-multithreading-in-ruby)
+  at [Cascadia Ruby 2013](http://cascadiaruby.com/) used [this](https://github.com/jdantonio/concurrent-ruby-presentation/tree/cascadia-ruby-2013) version of the presentation
+* I'll be giving ["Advanced Concurrent Programming in Ruby"](http://codemash.org/sessions)
+  at [CodeMash 2014](http://codemash.org/)
+
 ## Introduction
 
 The old-school "lock and synchronize" approach to concurrency is dead. The future of concurrency
@@ -55,12 +67,13 @@ Several features from Erlang, Go, Clojure, Java, and JavaScript have been implem
 
 * Clojure inspired [Agent](https://github.com/jdantonio/concurrent-ruby/blob/master/md/agent.md)
 * Clojure inspired [Future](https://github.com/jdantonio/concurrent-ruby/blob/master/md/future.md)
-* Scala inspired [Actor](http://www.scala-lang.org/api/current/index.html#scala.actors.Actor)
+* Scala inspired [Actor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/actor.md)
 * Go inspired [Goroutine](https://github.com/jdantonio/concurrent-ruby/blob/master/md/goroutine.md)
 * JavaScript inspired [Promise](https://github.com/jdantonio/concurrent-ruby/blob/master/md/promise.md)
 * Java inspired [Thread Pools](https://github.com/jdantonio/concurrent-ruby/blob/master/md/thread_pool.md)
 * Old school [events](http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx) from back in my Visual C++ days
 * Repeated task execution with Java inspired [TimerTask](https://github.com/jdantonio/concurrent-ruby/blob/master/md/timer_task.md) service
+* Scheduled task execution with Java inspired [ScheduledTask](https://github.com/jdantonio/concurrent-ruby/blob/master/md/scheduled_task.md) service
 * Erlang inspired [Supervisor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/supervisor.md) for managing long-running threads
 
 ### Is it any good?
@@ -161,7 +174,7 @@ sleep(1)
 p.value #=> "Hello Jerry D'Antonio. Would you like to play a game?" 
 ```
 
-#### Thread Pools
+#### Thread Pools (Java)
 
 ```ruby
 require 'concurrent'
@@ -199,7 +212,7 @@ sleep(1)
 #=> Zap!
 ```
 
-#### TimerTask
+#### TimerTask (Java)
 
 ```ruby
 require 'concurrent'
@@ -216,10 +229,47 @@ ec.status             #=> "sleep"
 ec.kill #=> true
 ```
 
+#### Actor (Scala)
+
+```ruby
+class FinanceActor < Concurrent::Actor
+  def act(query)
+    finance = Finance.new(query)
+    print "[#{Time.now}] RECEIVED '#{query}' to #{self} returned #{finance.update.suggested_symbols}\n\n"
+  end
+end
+
+financial, pool = FinanceActor.pool(5)
+
+pool << 'YAHOO'
+pool << 'Micosoft'
+pool << 'google'
+```
+
+#### Supervisor (Erlang)
+
+```ruby
+pong = Pong.new
+ping = Ping.new(10000, pong)
+pong.ping = ping
+
+task = Concurrent::TimerTask.new{ print "Boom!\n" }
+
+boss = Concurrent::Supervisor.new
+boss.add_worker(ping)
+boss.add_worker(pong)
+boss.add_worker(task)
+
+boss.run!
+
+ping << :pong
+```
+
 ## Todo
 
-* DelayedTask
-* More methods from Scala's Actor
+* [Task Parallel Library (TPL)](http://msdn.microsoft.com/en-us/library/dd460717.aspx)
+  * [Data Parallelism](http://msdn.microsoft.com/en-us/library/dd537608.aspx)
+  * [Task Parallelism](http://msdn.microsoft.com/en-us/library/dd537609.aspx)
 * More Erlang goodness
   * gen_server
   * gen_event

data/lib/concurrent.rb

@@ -3,12 +3,15 @@ require 'concurrent/version'
 
 require 'concurrent/actor'
 require 'concurrent/agent'
+require 'concurrent/contract'
+require 'concurrent/dereferenceable'
 require 'concurrent/event'
 require 'concurrent/future'
 require 'concurrent/goroutine'
 require 'concurrent/obligation'
 require 'concurrent/promise'
 require 'concurrent/runnable'
+require 'concurrent/scheduled_task'
 require 'concurrent/supervisor'
 require 'concurrent/timer_task'
 require 'concurrent/utilities'

data/lib/concurrent/actor.rb

@@ -1,23 +1,20 @@
 require 'thread'
 require 'observer'
 
+require 'concurrent/event'
+require 'concurrent/obligation'
 require 'concurrent/runnable'
 
 module Concurrent
 
-  # http://www.scala-lang.org/api/current/index.html#scala.actors.Actor
-  class Actor
-    include Observable
-    include Runnable
+  module Postable
 
-    def initialize
-      @queue = Queue.new
-    end
+    Package = Struct.new(:message, :handler, :notifier)
 
     def post(*message)
-      return false unless running?
-      @queue.push(message)
-      return @queue.length
+      return false unless ready?
+      queue.push(Package.new(message))
+      return queue.length
     end
 
     def <<(message)
@@ -25,6 +22,66 @@ module Concurrent
       return self
     end
 
+    def post?(*message)
+      return nil unless ready?
+      contract = Contract.new
+      queue.push(Package.new(message, contract))
+      return contract
+    end
+
+    def post!(seconds, *message)
+      raise Concurrent::Runnable::LifecycleError unless ready?
+      raise Concurrent::TimeoutError if seconds.to_f <= 0.0
+      event = Event.new
+      cback = Queue.new
+      queue.push(Package.new(message, cback, event))
+      if event.wait(seconds)
+        result = cback.pop
+        if result.is_a?(Exception)
+          raise result
+        else
+          return result
+        end
+      else
+        event.set # attempt to cancel
+        raise Concurrent::TimeoutError
+      end
+    end
+
+    def forward(receiver, *message)
+      return false unless ready?
+      queue.push(Package.new(message, receiver))
+      return queue.length
+    end
+
+    def ready?
+      if self.respond_to?(:running?) && ! running?
+        return false
+      else
+        return true
+      end
+    end
+
+    private
+
+    def queue
+      @queue ||= Queue.new
+    end
+  end
+
+  class Actor
+    include Observable
+    include Runnable
+    include Postable
+
+    class Poolbox
+      include Postable
+
+      def initialize(queue)
+        @queue = queue
+      end
+    end
+
     def self.pool(count, &block)
       raise ArgumentError.new('count must be greater than zero') unless count > 0
       mailbox = Queue.new
@@ -42,44 +99,41 @@ module Concurrent
       raise NotImplementedError.new("#{self.class} does not implement #act")
     end
 
-    class Poolbox
-
-      def initialize(queue)
-        @queue = queue
-      end
-
-      def post(*message)
-        @queue.push(message)
-        return @queue.length
-      end
-
-      def <<(message)
-        post(*message)
-        return self
-      end
-    end
-
     # @private
     def on_run # :nodoc:
-      @queue.clear
+      queue.clear
     end
 
     # @private
     def on_stop # :nodoc:
-      @queue.clear
-      @queue.push(:stop)
+      queue.clear
+      queue.push(:stop)
     end
 
     # @private
     def on_task # :nodoc:
-      message = @queue.pop
-      return if message == :stop
+      package = queue.pop
+      return if package == :stop
+      result = ex = nil
+      notifier = package.notifier
       begin
-        result = act(*message)
-        changed
-        notify_observers(Time.now, message, result)
+        if notifier.nil? || (notifier.is_a?(Event) && ! notifier.set?)
+          result = act(*package.message)
+        end
       rescue => ex
-        on_error(Time.now, message, ex)
+        on_error(Time.now, package.message, ex)
+      ensure
+        if package.handler.is_a?(Contract)
+          package.handler.complete(result, ex)
+        elsif notifier.is_a?(Event) && ! notifier.set?
+          package.handler.push(result || ex)
+          package.notifier.set
+        elsif package.handler.is_a?(Actor) && ex.nil?
+          package.handler.post(result)
+        end
+
+        changed
+        notify_observers(Time.now, package.message, result, ex)
       end
     end
 

data/lib/concurrent/agent.rb

@@ -1,6 +1,7 @@
 require 'thread'
 require 'observer'
 
+require 'concurrent/dereferenceable'
 require 'concurrent/global_thread_pool'
 require 'concurrent/utilities'
 
@@ -14,6 +15,7 @@ module Concurrent
   # A good example of an agent is a shared incrementing counter, such as the score in a video game.
   class Agent
     include Observable
+    include Dereferenceable
     include UsesGlobalThreadPool
 
     TIMEOUT = 5
@@ -25,29 +27,13 @@ module Concurrent
       @value = initial
       @rescuers = []
       @validator = nil
-
       @timeout = opts[:timeout] || TIMEOUT
-      @dup_on_deref = opts[:dup_on_deref] || opts[:dup] || false
-      @freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze] || false
-      @copy_on_deref = opts[:copy_on_deref] || opts[:copy]
-
-      @mutex = Mutex.new
-    end
-
-    def value(timeout = 0)
-      return @mutex.synchronize do
-        value = @value
-        value = @copy_on_deref.call(value) if @copy_on_deref
-        value = value.dup if @dup_on_deref
-        value = value.freeze if @freeze_on_deref
-        value
-      end
+      set_deref_options(opts)
     end
-    alias_method :deref, :value
 
     def rescue(clazz = nil, &block)
       unless block.nil?
-        @mutex.synchronize do
+        mutex.synchronize do
           @rescuers << Rescuer.new(clazz, block)
         end
       end
@@ -82,7 +68,7 @@ module Concurrent
 
     # @private
     def try_rescue(ex) # :nodoc:
-      rescuer = @mutex.synchronize do
+      rescuer = mutex.synchronize do
         @rescuers.find{|r| r.clazz.nil? || ex.is_a?(r.clazz) }
       end
       rescuer.block.call(ex) if rescuer
@@ -93,16 +79,16 @@ module Concurrent
     # @private
     def work(&handler) # :nodoc:
       begin
-        @mutex.synchronize do
+        mutex.synchronize do
           result = Concurrent::timeout(@timeout) do
             handler.call(@value)
           end
           if @validator.nil? || @validator.call(result)
             @value = result
             changed
-            notify_observers(Time.now, @value)
           end
         end
+        notify_observers(Time.now, self.value) if self.changed?
       rescue Exception => ex
         try_rescue(ex)
       end

data/lib/concurrent/contract.rb

@@ -0,0 +1,20 @@
+require 'concurrent/obligation'
+
+module Concurrent
+
+  class Contract
+    include Obligation
+
+    def initialize(opts = {})
+      @state = :pending
+      set_deref_options(opts)
+    end
+
+    def complete(value, reason)
+      @value = value
+      @reason = reason
+      @state = ( reason ? :rejected : :fulfilled )
+      event.set
+    end
+  end
+end

data/lib/concurrent/dereferenceable.rb

@@ -0,0 +1,33 @@
+module Concurrent
+
+  module Dereferenceable
+
+    def set_deref_options(opts = {})
+      mutex.synchronize do
+        @dup_on_deref = opts[:dup_on_deref] || opts[:dup] || false
+        @freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze] || false
+        @copy_on_deref = opts[:copy_on_deref] || opts[:copy]
+        @do_nothing_on_deref = ! (@dup_on_deref || @freeze_on_deref || @copy_on_deref)
+      end
+    end
+
+    def value
+      return nil if @value.nil?
+      return @value if @do_nothing_on_deref
+      return mutex.synchronize do
+        value = @value
+        value = @copy_on_deref.call(value) if @copy_on_deref
+        value = value.dup if @dup_on_deref
+        value = value.freeze if @freeze_on_deref
+        value
+      end
+    end
+    alias_method :deref, :value
+
+    protected
+
+    def mutex
+      @mutex ||= Mutex.new
+    end
+  end
+end

data/lib/concurrent/future.rb

@@ -12,7 +12,6 @@ module Concurrent
     include UsesGlobalThreadPool
 
     def initialize(*args, &block)
-      @mutex = Mutex.new
       unless block_given?
         @state = :fulfilled
       else
@@ -25,9 +24,10 @@ module Concurrent
     end
 
     def add_observer(observer, func = :update)
-      @mutex.synchronize do
+      val = self.value
+      mutex.synchronize do
         if event.set?
-          Future.thread_pool.post(func, Time.now, @value, @reason) do |f, *args|
+          Future.thread_pool.post(func, Time.now, val, @reason) do |f, *args|
             observer.send(f, *args)
           end
         else
@@ -48,12 +48,13 @@ module Concurrent
         @reason = ex
         @state = :rejected
       ensure
-        @mutex.synchronize {
+        val = self.value
+        mutex.synchronize do
           event.set
           changed
-          notify_observers(Time.now, @value, @reason)
+          notify_observers(Time.now, val, @reason)
           delete_observers
-        }
+        end
       end
     end
   end