concurrent-ruby 0.3.0.pre.1 → 0.3.0.pre.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed299ebc57fa2caa62d5538e28f6506d175be4f0
-  data.tar.gz: 4e160d0efeefab15be0c1767679079f9d07b5b59
+  metadata.gz: 2e3a37abe10cd8c068be7f5f34ec87ea665c4d8c
+  data.tar.gz: bbb6cf6902175de9995656c9ded8e611940edfb7
 SHA512:
-  metadata.gz: 5687e0000024468f66f42cfd4742ff672502ed6f9cde7a9579a84acfdcdfde8af33b2df28a0b387f36767bfefe3d70411b8efa7a5ba8cb3f7a684112db5a11ec
-  data.tar.gz: d8e45ab66ecb79ad64310e8a31f604c146840d9abf5bd51e9dcbf48279767dd0c9a02fad2f37e5bef25f9ec5ca656d92bf87ccbcced9e2aa7ff9bc8e9e47fca5
+  metadata.gz: 69f7670740cfb70d858462864993d38209050a435435cbd4a9202dda5146f3ab32629bc6e2206b016c2ec0d9a95b5ff1c7751a2ee8278ba6e6400fafb478d23f
+  data.tar.gz: 84ce8fdad2b1ccc72f93e6a5b08889937b9c27d2d4aea0560d191ac4e9338e5909fedbd1a9a128c228a36eb7f6fbcc6f3206130308658122d23d98e89a2a4239

data/README.md

@@ -55,12 +55,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)
 * 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
+* Erlang inspired [Supervisor](https://github.com/jdantonio/concurrent-ruby/blob/master/md/supervisor.md) for managing long-running threads
 
 ### Is it any good?
 
@@ -68,11 +69,10 @@ Several features from Erlang, Go, Clojure, Java, and JavaScript have been implem
 
 ### Supported Ruby versions
 
-MRI 1.9.2, 1.9.3, and 2.0. This library is pure Ruby and has minimal gem dependencies. It should be
-fully compatible with any Ruby interpreter that is 1.9.x compliant. I simply don't know enough
-about JRuby, Rubinius, or the others to fully support them. I can promise good karma and
-attribution on this page to anyone wishing to take responsibility for verifying compaitibility
-with any Ruby other than MRI.
+MRI 1.9.2, 1.9.3, 2.0, 2.1, and JRuby (1.9 mode). This library is pure Ruby and has no gem dependencies.
+It should be fully compatible with any Ruby interpreter that is 1.9.x compliant. I simply don't know enough
+about Rubinius or the others to fully support them. I can promise good karma and attribution on this page
+to anyone wishing to take responsibility for verifying compaitibility with any Ruby other than MRI.
 
 ### Install
 
@@ -94,25 +94,6 @@ Once you've installed the gem you must `require` it in your project:
 require 'concurrent'
 ```
 
-### Kernel Methods
-
-Many Ruby developers consider it bad form to add function to the global (Kernel) namespace.
-I don't necessarily agree. If the function acts like a low-level feature of the language
-I think it is OK to add the method to the `Kernel` module. To support my personal programming
-style I have chosen to implement `Kernel` methods to instance many of the objects in this
-library. Out of respect for the larger Ruby community I have made these methods optional.
-They are not imported with the normal `require 'concurrent'` directive. To import these
-functions you must import the `concurrent/functions` library.
-
-```ruby
-require 'concurrent'
-score = agent(10) #=> NoMethodError: undefined method `agent' for main:Object
-
-require 'concurrent/functions'
-score = agent(10) #=> #<Concurrent::Agent:0x35b2b28 ...
-score.value #=> 10
-```
-
 ### Examples
 
 For complete examples, see the specific documentation linked above. Below are a few examples to whet your appetite.
@@ -139,9 +120,8 @@ sleep(0.5)
 
 ```ruby
 require 'concurrent'
-require 'concurrent/functions'
 
-score = agent(10)
+score = Concurrent::Agent.new(10)
 score.value #=> 10
 
 score << proc{|current| current + 100 }
@@ -150,7 +130,7 @@ score.value #=> 110
 
 score << proc{|current| current * 2 }
 sleep(0.1)
-deref score #=> 220
+score.value #=> 220
 
 score << proc{|current| current - 50 }
 sleep(0.1)
@@ -161,22 +141,19 @@ score.value #=> 170
 
 ```ruby
 require 'concurrent'
-require 'concurrent/functions'
 
-count = future{ sleep(1); 10 }
+count = Concurrent::Future.new{ sleep(1); 10 }
 count.state #=> :pending
 # do stuff...
 count.value #=> 10 (after blocking)
-deref count #=> 10
 ```
 
 #### Promise (JavaScript)
 
 ```ruby
 require 'concurrent'
-require 'concurrent/functions'
 
-p = promise("Jerry", "D'Antonio"){|a, b| "#{a} #{b}" }.
+p = Concurrent::Promise.new("Jerry", "D'Antonio"){|a, b| "#{a} #{b}" }.
     then{|result| "Hello #{result}." }.
     rescue(StandardError){|ex| puts "Boom!" }.
     then{|result| "#{result} Would you like to play a game?"}

data/lib/concurrent.rb

@@ -1,14 +1,9 @@
-require 'thread'
-
-$ENABLE_BEHAVIOR_CHECK_ON_CONSTRUCTION ||= ( $DEGUG ? true : false )
-require 'functional'
-
 require 'concurrent/version'
 
-require 'concurrent/event'
 
+require 'concurrent/actor'
 require 'concurrent/agent'
-require 'concurrent/channel'
+require 'concurrent/event'
 require 'concurrent/executor'
 require 'concurrent/future'
 require 'concurrent/goroutine'
@@ -16,12 +11,11 @@ require 'concurrent/obligation'
 require 'concurrent/promise'
 require 'concurrent/runnable'
 require 'concurrent/supervisor'
+require 'concurrent/utilities'
+
+require 'concurrent/global_thread_pool'
 
-require 'concurrent/thread_pool'
 require 'concurrent/cached_thread_pool'
 require 'concurrent/fixed_thread_pool'
-require 'concurrent/null_thread_pool'
-
-require 'concurrent/global_thread_pool'
 
 require 'concurrent/event_machine_defer_proxy' if defined?(EventMachine)

data/lib/concurrent/{channel.rb → actor.rb}

@@ -5,15 +5,13 @@ require 'concurrent/runnable'
 
 module Concurrent
 
-  class Channel
+  # http://www.scala-lang.org/api/current/index.html#scala.actors.Actor
+  class Actor
     include Observable
     include Runnable
-    behavior(:runnable)
 
-    def initialize(errorback = nil, &block)
+    def initialize
       @queue = Queue.new
-      @task = block
-      @errorback = errorback
     end
 
     def post(*message)
@@ -27,19 +25,23 @@ module Concurrent
       return self
     end
 
-    def self.pool(count, errorback = nil, &block)
+    def self.pool(count, &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
+      actors = count.times.collect do
+        actor = self.new(&block)
+        actor.instance_variable_set(:@queue, mailbox)
+        actor
       end
-      return Poolbox.new(mailbox), channels
+      return Poolbox.new(mailbox), actors
     end
 
     protected
 
+    def act(*args)
+      raise NotImplementedError.new("#{self.class} does not implement #act")
+    end
+
     class Poolbox
 
       def initialize(queue)
@@ -73,7 +75,7 @@ module Concurrent
       message = @queue.pop
       return if message == :stop
       begin
-        result = receive(*message)
+        result = act(*message)
         changed
         notify_observers(Time.now, message, result)
       rescue => ex
@@ -83,12 +85,6 @@ module Concurrent
 
     # @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

data/lib/concurrent/agent.rb

@@ -2,6 +2,7 @@ require 'thread'
 require 'observer'
 
 require 'concurrent/global_thread_pool'
+require 'concurrent/utilities'
 
 module Concurrent
 
@@ -45,7 +46,7 @@ module Concurrent
     alias_method :deref, :value
 
     def rescue(clazz = nil, &block)
-      if block_given?
+      unless block.nil?
         @mutex.synchronize do
           @rescuers << Rescuer.new(clazz, block)
         end
@@ -56,7 +57,7 @@ module Concurrent
     alias_method :on_error, :rescue
 
     def validate(&block)
-      @validator = block if block_given?
+      @validator = block unless block.nil?
       return self
     end
     alias_method :validates, :validate
@@ -64,7 +65,7 @@ module Concurrent
     alias_method :validates_with, :validate
 
     def post(&block)
-      Agent.thread_pool.post{ work(&block) } if block_given?
+      Agent.thread_pool.post{ work(&block) } unless block.nil?
     end
 
     def <<(block)
@@ -93,7 +94,7 @@ module Concurrent
     def work(&handler) # :nodoc:
       begin
         @mutex.synchronize do
-          result = Timeout.timeout(@timeout) do
+          result = Concurrent::timeout(@timeout) do
             handler.call(@value)
           end
           if @validator.nil? || @validator.call(result)

data/lib/concurrent/cached_thread_pool.rb

@@ -1,51 +1,142 @@
-require 'concurrent/thread_pool'
+require 'thread'
+
+require 'concurrent/event'
+require 'concurrent/cached_thread_pool/worker'
 
 module Concurrent
 
-  class CachedThreadPool < AbstractThreadPool
-    behavior(:global_thread_pool)
+  class CachedThreadPool
+
+    MIN_POOL_SIZE = 1
+    MAX_POOL_SIZE = 256
 
     DEFAULT_THREAD_IDLETIME = 60
 
+    attr_accessor :max_threads
+
     def initialize(opts = {})
       @idletime = (opts[:idletime] || DEFAULT_THREAD_IDLETIME).to_i
-      super(opts)
+      raise ArgumentError.new('idletime must be greater than zero') if @idletime <= 0
+
+      @max_threads = opts[:max_threads] || opts[:max] || MAX_POOL_SIZE
+      if @max_threads < MIN_POOL_SIZE || @max_threads > MAX_POOL_SIZE
+        raise ArgumentError.new("size must be from #{MIN_POOL_SIZE} to #{MAX_POOL_SIZE}")
+      end
+
+      @state = :running
+      @pool = []
+      @terminator = Event.new
+      @mutex = Mutex.new
+
+      @busy = []
+      @idle = []
+    end
+
+    def <<(block)
+      self.post(&block)
+      return self
     end
 
     def post(*args, &block)
-      raise ArgumentError.new('no block given') unless block_given?
-      return @mutex.synchronize do
-        if @state == :running
-          @queue << [args, block]
-          at_capacity = @pool.empty? || ! @queue.empty? || @working >= @pool.size
-          if at_capacity && @pool.length < @max_threads
-            @pool << create_worker_thread
+      raise ArgumentError.new('no block given') if block.nil?
+      @mutex.synchronize do
+        break false unless @state == :running
+
+        if @idle.empty?
+          if @idle.length + @busy.length < @max_threads
+            worker = create_worker_thread
+          else
+            worker = @busy.shift
           end
-          true
         else
-          false
+          worker = @idle.pop
         end
+
+        @busy.push(worker)
+        worker.signal(*args, &block)
+
+        prune_stale_workers
+        true
       end
     end
 
-    protected
+    def running?
+      return @state == :running
+    end
+
+    def wait_for_termination(timeout = nil)
+      return @terminator.wait(timeout)
+    end
+
+    def shutdown
+      @mutex.synchronize do
+        break unless @state == :running
+        if @idle.empty? && @busy.empty?
+          @state = :shutdown
+          @terminator.set
+        else
+          @state = :shuttingdown
+          @idle.each{|worker| worker.stop }
+          @busy.each{|worker| worker.stop }
+        end
+      end
+    end
+
+    def kill
+      @mutex.synchronize do
+        break if @state == :shutdown
+        @state = :shutdown
+          @idle.each{|worker| worker.kill }
+          @busy.each{|worker| worker.kill }
+        @terminator.set
+      end
+    end
 
-    def dead_worker?(context)
-      return context.thread.nil? || context.thread.status == 'aborting' || ! context.thread.status
+    def length
+      @mutex.synchronize do
+        @state == :running ? @busy.length + @idle.length : 0
+      end
     end
 
-    def stale_worker?(context)
-      if context.status == :idle && @idletime <= (timestamp - context.idletime)
-        context.thread.kill
-        return true
-      else
-        return false
+    def on_worker_exit(worker)
+      @mutex.synchronize do
+        @idle.delete(worker)
+        @busy.delete(worker)
+        if @idle.empty? && @busy.empty? && @state != :running
+          @state = :shutdown
+          @terminator.set
+        end
       end
     end
 
-    def collect_garbage
-      @pool.reject! do |context|
-        dead_worker?(context) || stale_worker?(context)
+    def on_end_task(worker)
+      @mutex.synchronize do
+        break unless @state == :running
+        @busy.delete(worker)
+        @idle.push(worker)
+      end
+    end
+
+    protected
+
+    def create_worker_thread
+      wrkr = Worker.new(self)
+      Thread.new(wrkr, self) do |worker, parent|
+        Thread.current.abort_on_exception = false
+        worker.run
+        parent.on_worker_exit(worker)
+      end
+      return wrkr
+    end
+
+    def prune_stale_workers
+      @idle.reject! do |worker|
+        if worker.idletime > @idletime
+          worker.stop
+          true
+        else
+          worker.dead?
+        end
       end
     end
   end

data/lib/concurrent/cached_thread_pool/worker.rb

@@ -0,0 +1,91 @@
+require 'thread'
+
+module Concurrent
+
+  class CachedThreadPool
+
+    class Worker
+
+      def initialize(parent)
+        @parent = parent
+        @mutex = Mutex.new
+        @idletime = Time.now
+        @resource = ConditionVariable.new
+        @tasks = Queue.new
+      end
+     
+      def idle?
+        return ! @idletime.nil?
+      end
+
+      def dead?
+        return @mutex.synchronize do
+          @thread.nil? ? false : ! @thread.alive?
+        end
+      end
+
+      def idletime
+        return @mutex.synchronize do
+          @idletime.nil? ? 0 : Time.now.to_i - @idletime.to_i
+        end
+      end
+
+      def signal(*args, &block)
+        return @mutex.synchronize do
+          break(false) if @parent.nil?
+          @tasks << [args, block]
+          @resource.signal
+          true
+        end
+      end
+
+      def stop
+        return @mutex.synchronize do
+          @tasks.clear
+          @tasks << :stop
+          @resource.signal
+        end
+      end
+
+      def kill
+        @mutex.synchronize do
+          @idletime = Time.now
+          @parent = nil
+          Thread.kill(@thread) unless @thread.nil?
+          @thread = nil
+        end
+      end
+
+      def run(thread = Thread.current)
+        @mutex.synchronize do
+          raise StandardError.new('already running') unless @thread.nil?
+          @thread = thread
+        end
+
+        loop do
+          task = @mutex.synchronize do
+            @resource.wait(@mutex, 60) if @tasks.empty?
+
+            @tasks.pop(true)
+          end
+
+          if task == :stop
+            @thread = nil
+            @parent.on_worker_exit(self)
+            @parent = nil
+            break
+          end
+
+          #@parent.on_start_task(self)
+          begin
+            task.last.call(*task.first)
+          rescue
+            # let it fail
+          ensure
+            @parent.on_end_task(self)
+          end
+        end
+      end
+    end
+  end
+end