concurrent-ruby 0.2.2 → 0.3.0.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b0cd24fc7583a5575559eacbeeddc5d23fdae43f
-  data.tar.gz: addd7382eda8182216f5d86b0c53a75030c49439
+  metadata.gz: ed299ebc57fa2caa62d5538e28f6506d175be4f0
+  data.tar.gz: 4e160d0efeefab15be0c1767679079f9d07b5b59
 SHA512:
-  metadata.gz: 658d79b611fd7f572beeb73096b80addf9fab04ee8a06f75f914a3dd780dad86038519c5338d73fb540dd62d0683dce26c5c25b5419978bef79c5e72171e9052
-  data.tar.gz: fa5977a3f4bb3d1195f0aa4a00fc3fea84f86ee4d9d751d2c3d1916e6e94fe09daa74885016769e41d5640d7567cdc6d47e0bbd32cbdb8bf5546041a1bf9d3aa
+  metadata.gz: 5687e0000024468f66f42cfd4742ff672502ed6f9cde7a9579a84acfdcdfde8af33b2df28a0b387f36767bfefe3d70411b8efa7a5ba8cb3f7a684112db5a11ec
+  data.tar.gz: d8e45ab66ecb79ad64310e8a31f604c146840d9abf5bd51e9dcbf48279767dd0c9a02fad2f37e5bef25f9ec5ca656d92bf87ccbcced9e2aa7ff9bc8e9e47fca5

data/README.md

@@ -1,8 +1,11 @@
-# Concurrent Ruby [![Build Status](https://secure.travis-ci.org/jdantonio/concurrent-ruby.png)](https://travis-ci.org/jdantonio/concurrent-ruby?branch=master) [![Dependency Status](https://gemnasium.com/jdantonio/concurrent-ruby.png)](https://gemnasium.com/jdantonio/concurrent-ruby)
+# Concurrent Ruby [![Build Status](https://secure.travis-ci.org/jdantonio/concurrent-ruby.png)](https://travis-ci.org/jdantonio/concurrent-ruby?branch=master) [![Coverage Status](https://coveralls.io/repos/jdantonio/concurrent-ruby/badge.png)](https://coveralls.io/r/jdantonio/concurrent-ruby) [![Dependency Status](https://gemnasium.com/jdantonio/concurrent-ruby.png)](https://gemnasium.com/jdantonio/concurrent-ruby)
 
-Modern concurrency tools including agents, futures, promises, thread pools, reactors, supervisors, and more.
+Modern concurrency tools including agents, futures, promises, thread pools, supervisors, and more.
 Inspired by Erlang, Clojure, Go, JavaScript, actors, and classic concurrency patterns.
 
+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.
+
 ## Introduction
 
 The old-school "lock and synchronize" approach to concurrency is dead. The future of concurrency
@@ -51,12 +54,13 @@ Specifically:
 Several features from Erlang, Go, Clojure, Java, and JavaScript have been implemented thus far:
 
 * Clojure inspired [Agent](https://github.com/jdantonio/concurrent-ruby/blob/master/md/agent.md)
-* EventMachine inspired [Defer](https://github.com/jdantonio/concurrent-ruby/blob/master/md/defer.md)
 * Clojure inspired [Future](https://github.com/jdantonio/concurrent-ruby/blob/master/md/future.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(v=vs.85).aspx) from back in my Visual C++ days
 * Scheduled task execution with the [Executor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/executor.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?
 
@@ -118,10 +122,17 @@ For complete examples, see the specific documentation linked above. Below are a
 ```ruby
 require 'concurrent'
 
-@expected = nil
-go(1, 2, 3){|a, b, c| @expected = [c, b, a] }
-sleep(0.1)
-@expected #=> [3, 2, 1]
+go('foo'){|echo| sleep(0.1); print "#{echo}\n"; sleep(0.1); print "Boom!\n" }
+go('bar'){|echo| sleep(0.1); print "#{echo}\n"; sleep(0.1); print "Pow!\n" }
+go('baz'){|echo| sleep(0.1); print "#{echo}\n"; sleep(0.1); print "Zap!\n" }
+sleep(0.5)
+
+#=> foo
+#=> bar
+#=> baz
+#=> Boom!
+#=> Pow!
+#=> Zap!
 ```
 
 #### Agent (Clojure)
@@ -146,28 +157,6 @@ sleep(0.1)
 score.value #=> 170
 ```
 
-#### Defer (EventMachine)
-
-```ruby
-require 'concurrent'
-require 'concurrent/functions'
-
-Concurrent::Defer.new{ "Jerry D'Antonio" }.
-                  then{|result| puts "Hello, #{result}!" }.
-                  rescue{|ex| puts ex.message }.
-                  go
-
-#=> Hello, Jerry D'Antonio!
-
-operation = proc{ raise StandardError.new('Boom!') }
-callback  = proc{|result| puts result }
-errorback = proc{|ex| puts ex.message }
-defer(operation, callback, errorback)
-sleep(0.1)
-
-#=> "Boom!"
-```
-
 #### Future (Clojure)
 
 ```ruby
@@ -200,23 +189,37 @@ p.value #=> "Hello Jerry D'Antonio. Would you like to play a game?"
 ```ruby
 require 'concurrent'
 
-pool = Concurrent::FixedThreadPool.new(10)
-@expected = 0
-pool.post{ sleep(0.5); @expected += 100 }
-pool.post{ sleep(0.5); @expected += 100 }
-pool.post{ sleep(0.5); @expected += 100 }
-@expected #=> nil
+pool = Concurrent::FixedThreadPool.new(2)
+pool.size #=> 2
+
+pool.post{ sleep(0.5); print "Boom!\n" }
+pool.size #=> 2
+pool.post{ sleep(0.5); print "Pow!\n" }
+pool.size #=> 2
+pool.post{ sleep(0.5); print "Zap!\n" }
+pool.size #=> 2
+
 sleep(1)
-@expected #=> 300
+
+#=> Boom!
+#=> Pow!
+#=> Zap!
 
 pool = Concurrent::CachedThreadPool.new
-@expected = 0
-pool << proc{ sleep(0.5); @expected += 10 }
-pool << proc{ sleep(0.5); @expected += 10 }
-pool << proc{ sleep(0.5); @expected += 10 }
-@expected #=> 0
+pool.size #=> 0
+
+pool << proc{ sleep(0.5); print "Boom!\n" }
+pool.size #=> 1
+pool << proc{ sleep(0.5); print "Pow!\n" }
+pool.size #=> 2
+pool << proc{ sleep(0.5); print "Zap!\n" }
+pool.size #=> 3
+
 sleep(1)
-@expected #=> 30
+
+#=> Boom!
+#=> Pow!
+#=> Zap!
 ```
 
 #### Executor

data/lib/concurrent.rb

@@ -1,22 +1,21 @@
 require 'thread'
 
+$ENABLE_BEHAVIOR_CHECK_ON_CONSTRUCTION ||= ( $DEGUG ? true : false )
+require 'functional'
+
 require 'concurrent/version'
 
 require 'concurrent/event'
 
 require 'concurrent/agent'
-require 'concurrent/defer'
+require 'concurrent/channel'
 require 'concurrent/executor'
 require 'concurrent/future'
 require 'concurrent/goroutine'
 require 'concurrent/obligation'
 require 'concurrent/promise'
+require 'concurrent/runnable'
 require 'concurrent/supervisor'
-require 'concurrent/utilities'
-
-require 'concurrent/reactor'
-require 'concurrent/reactor/drb_async_demux'
-require 'concurrent/reactor/tcp_sync_demux'
 
 require 'concurrent/thread_pool'
 require 'concurrent/cached_thread_pool'

data/lib/concurrent/agent.rb

@@ -1,8 +1,7 @@
-require 'observer'
 require 'thread'
+require 'observer'
 
 require 'concurrent/global_thread_pool'
-require 'concurrent/utilities'
 
 module Concurrent
 
@@ -21,21 +20,31 @@ module Concurrent
     attr_reader :initial
     attr_reader :timeout
 
-    def initialize(initial, timeout = TIMEOUT)
+    def initialize(initial, opts = {})
       @value = initial
-      @timeout = timeout
       @rescuers = []
       @validator = nil
-      @queue = Queue.new
-      @mutex = Mutex.new
 
-      Agent.thread_pool.post{ work }
+      @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 @value; 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
+    end
     alias_method :deref, :value
 
-    def rescue(clazz = Exception, &block)
+    def rescue(clazz = nil, &block)
       if block_given?
         @mutex.synchronize do
           @rescuers << Rescuer.new(clazz, block)
@@ -55,11 +64,7 @@ module Concurrent
     alias_method :validates_with, :validate
 
     def post(&block)
-      return @queue.length unless block_given?
-      return @mutex.synchronize do
-        @queue << block
-        @queue.length
-      end
+      Agent.thread_pool.post{ work(&block) } if block_given?
     end
 
     def <<(block)
@@ -67,12 +72,6 @@ module Concurrent
       return self
     end
 
-    def length
-      return @queue.length
-    end
-    alias_method :size, :length
-    alias_method :count, :length
-
     alias_method :add_watch, :add_observer
 
     private
@@ -83,31 +82,28 @@ module Concurrent
     # @private
     def try_rescue(ex) # :nodoc:
       rescuer = @mutex.synchronize do
-        @rescuers.find{|r| ex.is_a?(r.clazz) }
+        @rescuers.find{|r| r.clazz.nil? || ex.is_a?(r.clazz) }
       end
       rescuer.block.call(ex) if rescuer
-    rescue Exception => e
+    rescue Exception => ex
       # supress
     end
 
     # @private
-    def work # :nodoc:
-      loop do
-        handler = @queue.pop
-        begin
+    def work(&handler) # :nodoc:
+      begin
+        @mutex.synchronize do
           result = Timeout.timeout(@timeout) do
             handler.call(@value)
           end
           if @validator.nil? || @validator.call(result)
-            @mutex.synchronize do
-              @value = result
-              changed
-              notify_observers(Time.now, @value)
-            end
+            @value = result
+            changed
+            notify_observers(Time.now, @value)
           end
-        rescue Exception => ex
-          try_rescue(ex)
         end
+      rescue Exception => ex
+        try_rescue(ex)
       end
     end
   end

data/lib/concurrent/cached_thread_pool.rb

@@ -1,131 +1,52 @@
-require 'thread'
-
 require 'concurrent/thread_pool'
-require 'concurrent/utilities'
-
-require 'functional/utilities'
 
 module Concurrent
 
-  def self.new_cached_thread_pool
-    return CachedThreadPool.new
-  end
+  class CachedThreadPool < AbstractThreadPool
+    behavior(:global_thread_pool)
 
-  class CachedThreadPool < ThreadPool
-    behavior(:thread_pool)
-
-    DEFAULT_GC_INTERVAL = 60
     DEFAULT_THREAD_IDLETIME = 60
 
-    attr_reader :working
-
     def initialize(opts = {})
-      @gc_interval = (opts[:gc_interval] || DEFAULT_GC_INTERVAL).freeze
-      @thread_idletime = (opts[:thread_idletime] || DEFAULT_THREAD_IDLETIME).freeze
-      super()
-      @working = 0
-    end
-
-    def kill
-      @status = :killed
-      mutex.synchronize do
-        @pool.each{|t| Thread.kill(t.thread) }
-      end
-    end
-
-    def size
-      return @pool.length
+      @idletime = (opts[:idletime] || DEFAULT_THREAD_IDLETIME).to_i
+      super(opts)
     end
 
     def post(*args, &block)
       raise ArgumentError.new('no block given') unless block_given?
-      if running?
-        collect_garbage if @pool.empty?
-        mutex.synchronize do
-          if @working >= @pool.length
-            create_worker_thread
-          end
+      return @mutex.synchronize do
+        if @state == :running
           @queue << [args, block]
-        end
-        return true
-      else
-        return false
-      end
-    end
-
-    # @private
-    def status # :nodoc:
-      mutex.synchronize do
-        @pool.collect do |worker|
-          [
-            worker.status,
-            worker.status == :idle ? delta(worker.idletime, timestamp) : nil,
-            worker.thread.status
-          ]
+          at_capacity = @pool.empty? || ! @queue.empty? || @working >= @pool.size
+          if at_capacity && @pool.length < @max_threads
+            @pool << create_worker_thread
+          end
+          true
+        else
+          false
         end
       end
     end
 
-    private
-
-    Worker = Struct.new(:status, :idletime, :thread)
-
-    # @private
-    def create_worker_thread # :nodoc:
-      worker = Worker.new(:idle, timestamp, nil)
-
-      worker.thread = Thread.new(worker) do |me|
-
-        loop do
-          task = @queue.pop
+    protected
 
-          mutex.synchronize do
-            @working += 1
-            me.status = :working
-          end
-
-          if task == :stop
-            me.status = :stopping
-            break
-          else
-            task.last.call(*task.first)
-            mutex.synchronize do
-              @working -= 1
-              me.status = :idle
-              me.idletime = timestamp
-            end
-          end
-        end
+    def dead_worker?(context)
+      return context.thread.nil? || context.thread.status == 'aborting' || ! context.thread.status
+    end
 
-        mutex.synchronize do
-          @pool.delete(me)
-          if @pool.empty?
-            @termination.set
-            @status = :shutdown unless killed?
-          end
-        end
+    def stale_worker?(context)
+      if context.status == :idle && @idletime <= (timestamp - context.idletime)
+        context.thread.kill
+        return true
+      else
+        return false
       end
-
-      worker.thread.abort_on_exception = false
-      @pool << worker
     end
 
-    # @private
-    def collect_garbage # :nodoc:
-      @collector = Thread.new do
-        loop do
-          sleep(@gc_interval)
-          mutex.synchronize do
-            @pool.reject! do |worker|
-              worker.thread.status.nil? ||
-                (worker.status == :idle && @thread_idletime >= delta(worker.idletime, timestamp))
-            end
-          end
-          @working = @pool.count{|worker| worker.status == :working}
-          break if @pool.empty?
-        end
+    def collect_garbage
+      @pool.reject! do |context|
+        dead_worker?(context) || stale_worker?(context)
       end
-      @collector.abort_on_exception = false
     end
   end
 end

data/lib/concurrent/channel.rb

@@ -0,0 +1,94 @@
+require 'thread'
+require 'observer'
+
+require 'concurrent/runnable'
+
+module Concurrent
+
+  class Channel
+    include Observable
+    include Runnable
+    behavior(:runnable)
+
+    def initialize(errorback = nil, &block)
+      @queue = Queue.new
+      @task = block
+      @errorback = errorback
+    end
+
+    def post(*message)
+      return false unless running?
+      @queue.push(message)
+      return @queue.length
+    end
+
+    def <<(message)
+      post(*message)
+      return self
+    end
+
+    def self.pool(count, errorback = nil, &block)
+      raise ArgumentError.new('count must be greater than zero') unless count > 0
+      mailbox = Queue.new
+      channels = count.times.collect do
+        channel = self.new(errorback, &block)
+        channel.instance_variable_set(:@queue, mailbox)
+        channel
+      end
+      return Poolbox.new(mailbox), channels
+    end
+
+    protected
+
+    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
+    end
+
+    # @private
+    def on_stop # :nodoc:
+      @queue.clear
+      @queue.push(:stop)
+    end
+
+    # @private
+    def on_task # :nodoc:
+      message = @queue.pop
+      return if message == :stop
+      begin
+        result = receive(*message)
+        changed
+        notify_observers(Time.now, message, result)
+      rescue => ex
+        on_error(Time.now, message, ex)
+      end
+    end
+
+    # @private
+    def on_error(time, msg, ex) # :nodoc:
+      @errorback.call(time, msg, ex) if @errorback
+    end
+
+    # @private
+    def receive(*message) # :nodoc:
+      @task.call(*message) unless @task.nil?
+    end
+  end
+end