concurrent-ruby 0.1.1 → 0.2.0

data/lib/concurrent/fixed_thread_pool.rb

@@ -26,8 +26,10 @@ module Concurrent
     end
 
     def kill
-      @status = :killed
-      @pool.each{|t| Thread.kill(t) }
+      mutex.synchronize do
+        @status = :killed
+        @pool.each{|t| Thread.kill(t) }
+      end
     end
 
     def size
@@ -50,7 +52,9 @@ module Concurrent
 
     # @private
     def status # :nodoc:
-      @pool.collect{|t| t.status }
+      mutex.synchronize do
+        @pool.collect{|t| t.status }
+      end
     end
 
     private
@@ -78,9 +82,11 @@ module Concurrent
     def collect_garbage # :nodoc:
       @collector = Thread.new do
         sleep(1)
-        @pool.size.times do |i|
-          if @pool[i].status.nil?
-            @pool[i] = create_worker_thread
+        mutex.synchronize do
+          @pool.size.times do |i|
+            if @pool[i].status.nil?
+              @pool[i] = create_worker_thread
+            end
           end
         end
       end

data/lib/concurrent/functions.rb

@@ -0,0 +1,120 @@
+require 'concurrent/agent'
+require 'concurrent/defer'
+require 'concurrent/future'
+require 'concurrent/promise'
+
+module Kernel
+
+  ## agent
+
+  def agent(initial, timeout = Concurrent::Agent::TIMEOUT)
+    return Concurrent::Agent.new(initial, timeout)
+  end
+  module_function :agent
+
+  def post(object, &block)
+    if object.respond_to?(:post)
+      return object.post(&block)
+    else
+      raise ArgumentError.new('object does not support #post')
+    end
+  end
+  module_function :post
+
+  ## defer
+
+  def defer(*args, &block)
+    return Concurrent::Defer.new(*args, &block)
+  end
+  module_function :defer
+
+  ## executor
+
+  def executor(*args, &block)
+    return Concurrent::Executor.run(*args, &block)
+  end
+  module_function :executor
+
+  ## future
+
+  def future(*args, &block)
+    return Concurrent::Future.new(*args, &block)
+  end
+  module_function :future
+
+  ## obligation
+
+  def deref(object, timeout = nil)
+    if object.respond_to?(:deref)
+      return object.deref(timeout)
+    elsif object.respond_to?(:value)
+      return object.value(timeout)
+    else
+      raise ArgumentError.new('object does not support #deref')
+    end
+  end
+  module_function :deref
+
+  def pending?(object)
+    if object.respond_to?(:pending?)
+      return object.pending?
+    else
+      raise ArgumentError.new('object does not support #pending?')
+    end
+  end
+  module_function :pending?
+
+  def fulfilled?(object)
+    if object.respond_to?(:fulfilled?)
+      return object.fulfilled?
+    elsif object.respond_to?(:realized?)
+      return object.realized?
+    else
+      raise ArgumentError.new('object does not support #fulfilled?')
+    end
+  end
+  module_function :fulfilled?
+
+  def realized?(object)
+    if object.respond_to?(:realized?)
+      return object.realized?
+    elsif object.respond_to?(:fulfilled?)
+      return object.fulfilled?
+    else
+      raise ArgumentError.new('object does not support #realized?')
+    end
+  end
+  module_function :realized?
+
+  def rejected?(object)
+    if object.respond_to?(:rejected?)
+      return object.rejected?
+    else
+      raise ArgumentError.new('object does not support #rejected?')
+    end
+  end
+  module_function :rejected?
+
+  ## promise
+
+  # Creates a new promise object. "A promise represents the eventual
+  # value returned from the single completion of an operation."
+  # Promises can be chained in a tree structure where each promise
+  # has zero or more children. Promises are resolved asynchronously
+  # in the order they are added to the tree. Parents are guaranteed
+  # to be resolved before their children. The result of each promise
+  # is passes to each of its children when the child resolves. When
+  # a promise is rejected all its children will be summarily rejected.
+  # A promise added to a rejected promise will immediately be rejected.
+  # A promise that is neither resolved or rejected is pending.
+  #
+  # @param args [Array] zero or more arguments for the block
+  # @param block [Proc] the block to call when attempting fulfillment
+  #
+  # @see Promise
+  # @see http://wiki.commonjs.org/wiki/Promises/A
+  def promise(*args, &block)
+    return Concurrent::Promise.new(*args, &block)
+  end
+  module_function :promise
+end

data/lib/concurrent/future.rb

@@ -8,17 +8,17 @@ module Concurrent
 
   class Future
     include Obligation
+    include UsesGlobalThreadPool
+
     behavior(:future)
 
     def initialize(*args, &block)
-
       unless block_given?
         @state = :fulfilled
       else
         @value = nil
         @state = :pending
-        $GLOBAL_THREAD_POOL.post do
-          Thread.pass
+        Future.thread_pool.post(*args) do
           work(*args, &block)
         end
       end
@@ -28,27 +28,15 @@ module Concurrent
 
     # @private
     def work(*args) # :nodoc:
-      semaphore.synchronize do
+      mutex.synchronize do
         begin
-          atomic {
-            @value = yield(*args)
-            @state = :fulfilled
-          }
+          @value = yield(*args)
+          @state = :fulfilled
         rescue Exception => ex
-          atomic {
-            @state = :rejected
-            @reason = ex
-          }
+          @state = :rejected
+          @reason = ex
         end
       end
     end
   end
 end
-
-module Kernel
-
-  def future(*args, &block)
-    return Concurrent::Future.new(*args, &block)
-  end
-  module_function :future
-end

data/lib/concurrent/global_thread_pool.rb

@@ -1,3 +1,16 @@
 require 'concurrent/cached_thread_pool'
 
 $GLOBAL_THREAD_POOL ||= Concurrent::CachedThreadPool.new
+
+module Concurrent
+
+  module UsesGlobalThreadPool
+
+    def self.included(base)
+      class << base
+        attr_accessor :thread_pool
+      end
+      base.thread_pool = $GLOBAL_THREAD_POOL
+    end
+  end
+end

data/lib/concurrent/goroutine.rb

@@ -19,7 +19,11 @@ module Kernel
   # @see https://gobyexample.com/goroutines
   def go(*args, &block)
     return false unless block_given?
-    $GLOBAL_THREAD_POOL.post(*args, &block)
+    if args.first.behaves_as?(:global_thread_pool)
+      args.first.post(*args.slice(1, args.length), &block)
+    else
+      $GLOBAL_THREAD_POOL.post(*args, &block)
+    end
   end
   module_function :go
 end

data/lib/concurrent/null_thread_pool.rb

@@ -0,0 +1,22 @@
+require 'concurrent/global_thread_pool'
+
+module Concurrent
+
+  class NullThreadPool
+    behavior(:global_thread_pool)
+
+    def self.post(*args, &block)
+      Thread.new(*args, &block)
+      return true
+    end
+
+    def post(*args, &block)
+      return NullThreadPool.post(*args, &block)
+    end
+
+    def <<(block)
+      NullThreadPool.post(&block)
+      return self
+    end
+  end
+end

data/lib/concurrent/obligation.rb

@@ -33,19 +33,23 @@ module Concurrent
     def fulfilled?() return(@state == :fulfilled); end
     alias_method :realized?, :fulfilled?
 
+    # Has the promise been rejected?
+    # @return [Boolean]
+    def rejected?() return(@state == :rejected); end
+
     # Is obligation completion still pending?
     # @return [Boolean]
-    def pending?() return(!(fulfilled? || rejected?)); end
+    def pending?() return(@state == :pending); end
 
     def value(timeout = nil)
-      if !pending? || timeout == 0
+      if timeout == 0 || ! pending?
         return @value
       elsif timeout.nil?
-        return semaphore.synchronize { @value }
+        return mutex.synchronize { v = @value }
       else
         begin
           return Timeout::timeout(timeout.to_f) {
-            semaphore.synchronize { @value }
+            mutex.synchronize { v = @value }
           }
         rescue Timeout::Error => ex
           return nil
@@ -54,68 +58,10 @@ module Concurrent
     end
     alias_method :deref, :value
 
-    # Has the promise been rejected?
-    # @return [Boolean]
-    def rejected?() return(@state == :rejected); end
-
     protected
 
-    def semaphore
-      @semaphore ||= Mutex.new
-    end
-  end
-end
-
-module Kernel
-
-  def deref(obligation, timeout = nil)
-    if obligation.respond_to?(:deref)
-      return obligation.deref(timeout)
-    elsif obligation.respond_to?(:value)
-      return obligation.deref(timeout)
-    else
-      return nil
-    end
-  end
-  module_function :deref
-
-  def pending?(obligation)
-    if obligation.respond_to?(:pending?)
-      return obligation.pending?
-    else
-      return false
-    end
-  end
-  module_function :pending?
-
-  def fulfilled?(obligation)
-    if obligation.respond_to?(:fulfilled?)
-      return obligation.fulfilled?
-    elsif obligation.respond_to?(:realized?)
-      return obligation.realized?
-    else
-      return false
-    end
-  end
-  module_function :fulfilled?
-
-  def realized?(obligation)
-    if obligation.respond_to?(:realized?)
-      return obligation.realized?
-    elsif obligation.respond_to?(:fulfilled?)
-      return obligation.fulfilled?
-    else
-      return false
-    end
-  end
-  module_function :realized?
-
-  def rejected?(obligation)
-    if obligation.respond_to?(:rejected?)
-      return obligation.rejected?
-    else
-      return false
+    def mutex
+      @mutex ||= Mutex.new
     end
   end
-  module_function :rejected?
 end

data/lib/concurrent/promise.rb

@@ -1,5 +1,6 @@
 require 'thread'
 
+require 'concurrent/global_thread_pool'
 require 'concurrent/obligation'
 require 'concurrent/utilities'
 
@@ -7,6 +8,8 @@ module Concurrent
 
   class Promise
     include Obligation
+    include UsesGlobalThreadPool
+
     behavior(:future)
     behavior(:promise)
 
@@ -33,17 +36,22 @@ module Concurrent
         @chain = [self]
       end
 
-      @mutex = Mutex.new
+      @lock = Mutex.new
       @handler = block || Proc.new{|result| result }
       @state = :pending
       @value = nil
       @reason = nil
+      @rescued = false
       @children = []
       @rescuers = []
 
       realize(*args) if root?
     end
 
+    def rescued?
+      return @rescued
+    end
+
     # Create a new child Promise. The block argument for the child will
     # be the result of fulfilling its parent. If the child will
     # immediately be rejected if the parent has already been rejected.
@@ -52,7 +60,7 @@ module Concurrent
     #
     # @return [Promise] the new promise
     def then(&block)
-      child = @mutex.synchronize do
+      child = @lock.synchronize do
         block = Proc.new{|result| result } unless block_given?
         @children << Promise.new(self, &block)
         @children.last.on_reject(@reason) if rejected?
@@ -73,8 +81,14 @@ module Concurrent
     #
     # @return [self] so that additional chaining can occur
     def rescue(clazz = Exception, &block)
-      @mutex.synchronize do
-        @rescuers << Rescuer.new(clazz, block) if block_given?
+      return self if fulfilled? || rescued? || ! block_given?
+      @lock.synchronize do
+        rescuer = Rescuer.new(clazz, block)
+        if pending?
+          @rescuers << rescuer
+        else
+          try_rescue(reason, rescuer)
+        end
       end
       return self
     end
@@ -90,15 +104,6 @@ module Concurrent
     # @private
     Rescuer = Struct.new(:clazz, :block)
 
-    # @private
-    def root # :nodoc:
-      return atomic {
-        current = self
-        current = current.parent until current.root?
-        current
-      }
-    end
-
     # @private
     def root? # :nodoc:
       @parent.nil?
@@ -115,47 +120,44 @@ module Concurrent
 
     # @private
     def on_fulfill(value) # :nodoc:
-      @mutex.synchronize do
-        if pending?
-          @value = @handler.call(value)
-          @state = :fulfilled
-          @reason = nil
-        end
+      @lock.synchronize do
+        @value = @handler.call(value)
+        @state = :fulfilled
+        @reason = nil
       end
       return @value
     end
 
     # @private
     def on_reject(reason) # :nodoc:
-      @mutex.synchronize do
-        if pending?
-          @state = :rejected
-          @reason = reason
-          self.try_rescue(reason)
-          @value = nil
-        end
-        @children.each{|child| child.on_reject(reason) }
-      end
+      @value = nil
+      @state = :rejected
+      @reason = reason
+      try_rescue(reason)
+      @children.each{|child| child.on_reject(reason) }
     end
 
     # @private
-    def try_rescue(ex) # :nodoc:
-      rescuer = @rescuers.find{|r| ex.is_a?(r.clazz) }
-      rescuer.block.call(ex) if rescuer
+    def try_rescue(ex, *rescuers) # :nodoc:
+      rescuers = @rescuers if rescuers.empty?
+      rescuer = rescuers.find{|r| ex.is_a?(r.clazz) }
+      if rescuer
+        rescuer.block.call(ex)
+        @rescued = true
+      end
     rescue Exception => e
       # supress
     end
 
     # @private
     def realize(*args) # :nodoc:
-      Thread.new(@chain, @mutex, args) do |chain, mutex, args|
+      Promise.thread_pool.post(@chain, @lock, args) do |chain, lock, args|
         result = args.length == 1 ? args.first : args
         index = 0
         loop do
-          Thread.pass
-          current = mutex.synchronize{ chain[index] }
+          current = lock.synchronize{ chain[index] }
           unless current.rejected?
-            current.semaphore.synchronize do
+            current.mutex.synchronize do
               begin
                 result = current.on_fulfill(result)
               rescue Exception => ex
@@ -164,33 +166,9 @@ module Concurrent
             end
           end
           index += 1
-          sleep while index >= chain.length
+          Thread.pass while index >= chain.length
         end
       end
     end
   end
 end
-
-module Kernel
-
-  # Creates a new promise object. "A promise represents the eventual
-  # value returned from the single completion of an operation."
-  # Promises can be chained in a tree structure where each promise
-  # has zero or more children. Promises are resolved asynchronously
-  # in the order they are added to the tree. Parents are guaranteed
-  # to be resolved before their children. The result of each promise
-  # is passes to each of its children when the child resolves. When
-  # a promise is rejected all its children will be summarily rejected.
-  # A promise added to a rejected promise will immediately be rejected.
-  # A promise that is neither resolved or rejected is pending.
-  #
-  # @param args [Array] zero or more arguments for the block
-  # @param block [Proc] the block to call when attempting fulfillment
-  #
-  # @see Promise
-  # @see http://wiki.commonjs.org/wiki/Promises/A
-  def promise(*args, &block)
-    return Concurrent::Promise.new(*args, &block)
-  end
-  module_function :promise
-end