concurrent-ruby 0.7.1-x86-linux → 0.7.2-x86-linux

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWZiNWIzMzZmNmQwYjcwYWM4YTVjN2VmMWJiMmMzZTZhYWQyMDUzZQ==
+    M2FhN2YzZTJhN2UwZTQwYWMyNWI4YjJkMmQzOTMwNDZjNzc5ZWYzZg==
   data.tar.gz: !binary |-
-    YzAwZTNmYTQ0NTZkMjEyYzY4OWI3NjU5NGM3YzFjYjYzOTQ1MmMyNQ==
+    MTRlZjI4ODk1YWM3YWViNzk4NTc0MDE5NjdkNjhmMGNiYTZjOTFlZA==
 SHA512:
   metadata.gz: !binary |-
-    MTQwZjYwOGQyNDE4MmU1NTBiZTExNjNjMGNjMWEzYTlkM2M5NDc5OTgwNTEw
-    ZWUwOWJmNGQxNGJkMDA5MGJmODUwODBlMDk3YTlkZjBmMzM2MDYzZTIwYjA2
-    MDcxMmRiODYwNjc4YTk5YWYyMmI3YWYwODg2NGRmODJhMThjMzQ=
+    YjlhYTIwMzRjZGYxOWE1YjFiZmRkM2M0ZDI1OTkzOTFlOWQyNGZkNzBjYWYz
+    YWVjNDBmMmM0NjU3Y2IxMGUxZDhlMjk2MWE4NjQ3ODhjMDg0MDE3NWQ4NGE4
+    MDYxYTYzNWY0YmVkMDU3ZmI0MTdkNmUyOWExNmQ3NWMzYzQ0OWM=
   data.tar.gz: !binary |-
-    NDQzMDk4ZTE3NmNkYWJjYjQ5M2Y0NGU3ODQ2YzliMzFhZjE2MTg4NGYwN2Zj
-    NzM3NmMwMGRkYjM0MjFlMzgzNWU1ZTY3NWI4ZmE2MWExN2M2NGM0YzdkMTAx
-    MjI4MTVhZTg0NDFjODVhOTc1NmMwNDg0Nzg2YzNkZDM2MzRhM2I=
+    MTk4Mjc5YTU5MjBmMWYzMThjMzY3MTdlMDUyOTYzZmNlOTg0OThmYmU4MzI0
+    NmNhYTRhMmVhN2YwYTUxNDIwOTAxNDliNDIwYjJjN2U3ODc2YmI1OGZiZjVm
+    ZWZlZGVkNjVlNzk1MzUzOWRiY2VlODQ0OWZlMmI4ZjUyNDU3MGE=

data/CHANGELOG.md

@@ -1,3 +1,20 @@
+### Next Release v0.7.2 (24 January 2015)
+
+* New `Semaphore` class based on [java.util.concurrent.Semaphore](http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Semaphore.html)
+* New `Promise.all?` and `Promise.any?` class methods
+* Renamed `:overflow_policy` on thread pools to `:fallback_policy`
+* Thread pools still accept the `:overflow_policy` option but display a warning
+* Thread pools now implement `fallback_policy` behavior when not running (rather than universally rejecting tasks)
+* Fixed minor `set_deref_options` constructor bug in `Promise` class
+* Fixed minor `require` bug in `ThreadLocalVar` class
+* Fixed race condition bug in `TimerSet` class
+* Fixed race condition bug in `TimerSet` class
+* Fixed signal bug in `TimerSet#post` method
+* Numerous non-functional updates to clear warning when running in debug mode
+* Fixed more intermittently failing tests
+* Tests now run on new Travis build environment
+* Multiple documentation updates
+
 ## Current Release v0.7.1 (4 December 2014)
 
 Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/issues/142) for more information on the next planned release.

data/README.md

@@ -54,19 +54,18 @@ This library contains a variety of concurrency abstractions at high and low leve
 
 ### High-level, general-purpose asynchronous concurrency abstractions
 
-* [Actor](./doc/actor/main.md): Implements the Actor Model, where concurrent actors exchange messages. 
-* [Agent](./doc/agent.md): A single atomic value that represents an identity.
-* [Async](./doc/async.md): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
-* [Future](./doc/future.md): An asynchronous operation that produces a value.
-  * [Dataflow](./doc/dataflow.md): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
-* [Promise](./doc/promise.md): Similar to Futures, with more features. 
-* [ScheduledTask](./doc/scheduled_task.md): Like a Future scheduled for a specific future time. 
+* [Actor](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Actor.html): Implements the Actor Model, where concurrent actors exchange messages.
+* [Agent](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Agent.html): A single atomic value that represents an identity.
+* [Async](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Async.html): A mixin module that provides simple asynchronous behavior to any standard class/object or object.
+* [Future](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Future.html): An asynchronous operation that produces a value.
+  * [Dataflow](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Dataflow.html): Built on Futures, Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+* [Promise](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Promise.html): Similar to Futures, with more features.
+* [ScheduledTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ScheduledTask.html): Like a Future scheduled for a specific future time.
 * [TimerTask](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TimerTask.html): A Thread that periodically wakes up to perform work at regular intervals. 
 
-
 ### Java-inspired ThreadPools and other executors
 
-* See [ThreadPool](./doc/thread_pools.md) overview, which also contains a list of other Executors available.
+* See [ThreadPool](http://ruby-concurrency.github.io/concurrent-ruby/file.thread_pools.html) overview, which also contains a list of other Executors available.
 
 ### Thread-safe Observers
 
@@ -75,6 +74,7 @@ This library contains a variety of concurrency abstractions at high and low leve
 * [CopyOnWriteObserverSet](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CopyOnWriteObserverSet.html)
 
 ### Thread synchronization classes and algorithms
+
 Lower-level abstractions mainly used as building blocks. 
 
 * [condition](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Condition.html)
@@ -82,10 +82,12 @@ Lower-level abstractions mainly used as building blocks.
 * [cyclic barrier](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/CyclicBarrier.html)
 * [event](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Event.html)
 * [exchanger](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Exchanger.html)
+* [semaphore](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/Semaphore.html)
 * [timeout](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timeout-class_method)
 * [timer](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent.html#timer-class_method)
 
 ### Thread-safe variables
+
 Lower-level abstractions mainly used as building blocks. 
 
 * [AtomicBoolean](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/AtomicBoolean.html)
@@ -94,9 +96,7 @@ Lower-level abstractions mainly used as building blocks.
 * [I-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/IVar.html) (IVar)
 * [M-Structures](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/MVar.html) (MVar)
 * [thread-local variables](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/ThreadLocalVar.html)
-* [software transactional memory](./doc/tvar.md) (TVar)
-
-
+* [software transactional memory](http://ruby-concurrency.github.io/concurrent-ruby/Concurrent/TVar.html) (TVar)
 
 ## Installing and Building
 

data/lib/concurrent/async.rb

@@ -81,13 +81,13 @@ module Concurrent
         super unless @delegate.respond_to?(method)
         Async::validate_argc(@delegate, method, *args)
 
-        self.define_singleton_method(method) do |*args|
-          Async::validate_argc(@delegate, method, *args)
+        self.define_singleton_method(method) do |*args2|
+          Async::validate_argc(@delegate, method, *args2)
           ivar = Concurrent::IVar.new
           value, reason = nil, nil
           @serializer.post(@executor.value) do
             begin
-              value = @delegate.send(method, *args, &block)
+              value = @delegate.send(method, *args2, &block)
             rescue => reason
               # caught
             ensure

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -25,8 +25,8 @@ module Concurrent
   class MutexAtomicFixnum
 
     # http://stackoverflow.com/questions/535721/ruby-max-integer
-    MIN_VALUE = -(2**(0.size * 8 -2))
-    MAX_VALUE = (2**(0.size * 8 -2) -1)
+    MIN_VALUE = -(2**(0.size * 8 - 2))
+    MAX_VALUE = (2**(0.size * 8 - 2) - 1)
 
     # @!macro [attach] atomic_fixnum_method_initialize
     #

data/lib/concurrent/atomic/semaphore.rb

@@ -0,0 +1,232 @@
+require 'concurrent/atomic/condition'
+
+module Concurrent
+  class MutexSemaphore
+    # @!macro [attach] semaphore_method_initialize
+    #
+    #   Create a new `Semaphore` with the initial `count`.
+    #
+    #   @param [Fixnum] count the initial count
+    #
+    #   @raise [ArgumentError] if `count` is not an integer or is less than zero
+    def initialize(count)
+      unless count.is_a?(Fixnum) && count >= 0
+        fail ArgumentError, 'count must be an non-negative integer'
+      end
+      @mutex = Mutex.new
+      @condition = Condition.new
+      @free = count
+    end
+
+    # @!macro [attach] semaphore_method_acquire
+    #
+    #   Acquires the given number of permits from this semaphore,
+    #     blocking until all are available.
+    #
+    #   @param [Fixnum] permits Number of permits to acquire
+    #
+    #   @raise [ArgumentError] if `permits` is not an integer or is less than
+    #     one
+    #
+    #   @return [Nil]
+    def acquire(permits = 1)
+      unless permits.is_a?(Fixnum) && permits > 0
+        fail ArgumentError, 'permits must be an integer greater than zero'
+      end
+      @mutex.synchronize do
+        try_acquire_timed(permits, nil)
+        nil
+      end
+    end
+
+    # @!macro [attach] semaphore_method_available_permits
+    #
+    #   Returns the current number of permits available in this semaphore.
+    #
+    #   @return [Integer]
+    def available_permits
+      @mutex.synchronize { @free }
+    end
+
+    # @!macro [attach] semaphore_method_drain_permits
+    #
+    #   Acquires and returns all permits that are immediately available.
+    #
+    #   @return [Integer]
+    def drain_permits
+      @mutex.synchronize do
+        @free.tap { |_| @free = 0 }
+      end
+    end
+
+    # @!macro [attach] semaphore_method_try_acquire
+    #
+    #   Acquires the given number of permits from this semaphore,
+    #     only if all are available at the time of invocation or within
+    #     `timeout` interval
+    #
+    #   @param [Fixnum] permits the number of permits to acquire
+    #
+    #   @param [Fixnum] timeout the number of seconds to wait for the counter
+    #     or `nil` to return immediately
+    #
+    #   @raise [ArgumentError] if `permits` is not an integer or is less than
+    #     one
+    #
+    #   @return [Boolean] `false` if no permits are available, `true` when
+    #     acquired a permit
+    def try_acquire(permits = 1, timeout = nil)
+      unless permits.is_a?(Fixnum) && permits > 0
+        fail ArgumentError, 'permits must be an integer greater than zero'
+      end
+      @mutex.synchronize do
+        if timeout.nil?
+          try_acquire_now(permits)
+        else
+          try_acquire_timed(permits, timeout)
+        end
+      end
+    end
+
+    # @!macro [attach] semaphore_method_release
+    #
+    #   Releases the given number of permits, returning them to the semaphore.
+    #
+    #   @param [Fixnum] permits Number of permits to return to the semaphore.
+    #
+    #   @raise [ArgumentError] if `permits` is not a number or is less than one
+    #
+    #   @return [Nil]
+    def release(permits = 1)
+      unless permits.is_a?(Fixnum) && permits > 0
+        fail ArgumentError, 'permits must be an integer greater than zero'
+      end
+      @mutex.synchronize do
+        @free += permits
+        permits.times { @condition.signal }
+      end
+      nil
+    end
+
+    # @!macro [attach] semaphore_method_reduce_permits
+    # 
+    #   @api private
+    #
+    #   Shrinks the number of available permits by the indicated reduction.
+    #
+    #   @param [Fixnum] reduction Number of permits to remove.
+    #
+    #   @raise [ArgumentError] if `reduction` is not an integer or is negative
+    #
+    #   @raise [ArgumentError] if `@free` - `@reduction` is less than zero
+    #
+    #   @return [Nil]
+    def reduce_permits(reduction)
+      unless reduction.is_a?(Fixnum) && reduction >= 0
+        fail ArgumentError, 'reduction must be an non-negative integer'
+      end
+      @mutex.synchronize { @free -= reduction }
+      nil 
+    end
+
+    private
+
+    def try_acquire_now(permits)
+      if @free >= permits
+        @free -= permits
+        true
+      else
+        false
+      end
+    end
+
+    def try_acquire_timed(permits, timeout)
+      remaining = Condition::Result.new(timeout)
+      while !try_acquire_now(permits) && remaining.can_wait?
+        @condition.signal
+        remaining = @condition.wait(@mutex, remaining.remaining_time)
+      end
+      remaining.can_wait? ? true : false
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro semaphore
+    #     
+    #   A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each {#acquire} blocks if necessary
+    #   until a permit is available, and then takes it. Each {#release} adds a permit,
+    #   potentially releasing a blocking acquirer.
+    #   However, no actual permit objects are used; the Semaphore just keeps a count of the number available and
+    #   acts accordingly.
+    class JavaSemaphore
+      # @!macro semaphore_method_initialize
+      def initialize(count)
+        unless count.is_a?(Fixnum) && count >= 0
+          fail(ArgumentError,
+               'count must be in integer greater than or equal zero')
+        end
+        @semaphore = java.util.concurrent.Semaphore.new(count)
+      end
+
+      # @!macro semaphore_method_acquire
+      def acquire(permits = 1)
+        unless permits.is_a?(Fixnum) && permits > 0
+          fail ArgumentError, 'permits must be an integer greater than zero'
+        end
+        @semaphore.acquire(permits)
+      end
+
+      # @!macro semaphore_method_available_permits
+      def available_permits
+        @semaphore.availablePermits
+      end
+
+      # @!macro semaphore_method_drain_permits
+      def drain_permits
+        @semaphore.drainPermits
+      end
+
+      # @!macro semaphore_method_try_acquire
+      def try_acquire(permits = 1, timeout = nil)
+        unless permits.is_a?(Fixnum) && permits > 0
+          fail ArgumentError, 'permits must be an integer greater than zero'
+        end
+        if timeout.nil?
+          @semaphore.tryAcquire(permits)
+        else
+          @semaphore.tryAcquire(permits,
+                                 timeout,
+                                 java.util.concurrent.TimeUnit::SECONDS)
+        end
+      end
+
+      # @!macro semaphore_method_release
+      def release(permits = 1)
+        unless permits.is_a?(Fixnum) && permits > 0
+          fail ArgumentError, 'permits must be an integer greater than zero'
+        end
+        @semaphore.release(permits)
+        true
+      end
+
+      # @!macro semaphore_method_reduce_permits
+      def reduce_permits(reduction)
+        unless reduction.is_a?(Fixnum) && reduction >= 0
+          fail ArgumentError, 'reduction must be an non-negative integer'
+        end
+        @semaphore.reducePermits(reduction)
+      end
+    end
+
+    # @!macro semaphore
+    class Semaphore < JavaSemaphore
+    end
+
+  else
+
+    # @!macro semaphore
+    class Semaphore < MutexSemaphore
+    end
+  end
+end

data/lib/concurrent/atomics.rb

@@ -8,3 +8,5 @@ require 'concurrent/atomic/cyclic_barrier'
 require 'concurrent/atomic/count_down_latch'
 require 'concurrent/atomic/event'
 require 'concurrent/atomic/synchronization'
+require 'concurrent/atomic/semaphore'
+require 'concurrent/atomic/thread_local_var'

data/lib/concurrent/configuration.rb

@@ -102,7 +102,7 @@ module Concurrent
           max_threads:     [20, Concurrent.processor_count * 15].max,
           idletime:        2 * 60, # 2 minutes
           max_queue:       0, # unlimited
-          overflow_policy: :abort # raise an exception
+          fallback_policy: :abort # raise an exception
       )
     end
 
@@ -112,7 +112,7 @@ module Concurrent
           max_threads:     [2, Concurrent.processor_count].max,
           idletime:        10 * 60, # 10 minutes
           max_queue:       [20, Concurrent.processor_count * 15].max,
-          overflow_policy: :abort # raise an exception
+          fallback_policy: :abort # raise an exception
       )
     end
   end

data/lib/concurrent/executor/executor.rb

@@ -5,7 +5,12 @@ require 'concurrent/atomic/event'
 module Concurrent
 
   module Executor
-    
+    # The policy defining how rejected tasks (tasks received once the
+    # queue size reaches the configured `max_queue`, or after the
+    # executor has shut down) are handled. Must be one of the values
+    # specified in `FALLBACK_POLICIES`.
+    attr_reader :fallback_policy
+
     # @!macro [attach] executor_module_method_can_overflow_question
     #
     #   Does the task queue have a maximum size?
@@ -17,6 +22,31 @@ module Concurrent
       false
     end
 
+    # Handler which executes the `fallback_policy` once the queue size
+    # reaches `max_queue`.
+    #
+    # @param [Array] args the arguments to the task which is being handled.
+    #
+    # @!visibility private
+    def handle_fallback(*args)
+      case @fallback_policy
+      when :abort
+        raise RejectedExecutionError
+      when :discard
+        false
+      when :caller_runs
+        begin
+          yield(*args)
+        rescue => ex
+          # let it fail
+          log DEBUG, ex
+        end
+        true
+      else
+        fail "Unknown fallback policy #{@fallback_policy}"
+      end
+    end
+
     # @!macro [attach] executor_module_method_serialized_question
     #
     #   Does this executor guarantee serialization of its operations?
@@ -63,6 +93,9 @@ module Concurrent
     include Executor
     include Logging
 
+    # The set of possible fallback policies that may be set at thread pool creation.
+    FALLBACK_POLICIES          = [:abort, :discard, :caller_runs]
+
     # @!macro [attach] executor_method_post
     #
     #   Submit a task to the executor for asynchronous processing.
@@ -78,7 +111,8 @@ module Concurrent
     def post(*args, &task)
       raise ArgumentError.new('no block given') unless block_given?
       mutex.synchronize do
-        return false unless running?
+        # If the executor is shut down, reject this task
+        return handle_fallback(*args, &task) unless running?
         execute(*args, &task)
         true
       end
@@ -210,16 +244,20 @@ module Concurrent
       include Executor
       java_import 'java.lang.Runnable'
 
+      # The set of possible fallback policies that may be set at thread pool creation.
+      FALLBACK_POLICIES = {
+        abort: java.util.concurrent.ThreadPoolExecutor::AbortPolicy,
+        discard: java.util.concurrent.ThreadPoolExecutor::DiscardPolicy,
+        caller_runs: java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
+      }.freeze
+
       # @!macro executor_method_post
-      def post(*args)
+      def post(*args, &task)
         raise ArgumentError.new('no block given') unless block_given?
-        if running?
-          executor_submit = @executor.java_method(:submit, [Runnable.java_class])
-          executor_submit.call { yield(*args) }
-          true
-        else
-          false
-        end
+        return handle_fallback(*args, &task) unless running?
+        executor_submit = @executor.java_method(:submit, [Runnable.java_class])
+        executor_submit.call { yield(*args) }
+        true
       rescue Java::JavaUtilConcurrent::RejectedExecutionException
         raise RejectedExecutionError
       end

data/lib/concurrent/executor/indirect_immediate_executor.rb

@@ -28,7 +28,7 @@ module Concurrent
       return false unless running?
 
       event = Concurrent::Event.new
-      internal_executor.post do
+      @internal_executor.post do
         begin
           task.call(*args)
         ensure
@@ -39,8 +39,5 @@ module Concurrent
 
       true
     end
-
-    private
-    attr_reader :internal_executor
   end
 end

data/lib/concurrent/executor/java_cached_thread_pool.rb

@@ -10,19 +10,20 @@ if RUBY_PLATFORM == 'java'
       # Create a new thread pool.
       #
       # @param [Hash] opts the options defining pool behavior.
-      # @option opts [Symbol] :overflow_policy (`:abort`) the overflow policy
+      # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
       #
-      # @raise [ArgumentError] if `overflow_policy` is not a known policy
+      # @raise [ArgumentError] if `fallback_policy` is not a known policy
       #
       # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
       def initialize(opts = {})
-        @overflow_policy = opts.fetch(:overflow_policy, :abort)
+        @fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
+        warn '[DEPRECATED] :overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
         @max_queue = 0
 
-        raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+        raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.keys.include?(@fallback_policy)
 
         @executor = java.util.concurrent.Executors.newCachedThreadPool
-        @executor.setRejectedExecutionHandler(OVERFLOW_POLICIES[@overflow_policy].new)
+        @executor.setRejectedExecutionHandler(FALLBACK_POLICIES[@fallback_policy].new)
 
         set_shutdown_hook
       end

data/lib/concurrent/executor/java_fixed_thread_pool.rb

@@ -10,10 +10,10 @@ if RUBY_PLATFORM == 'java'
       # Create a new thread pool.
       #
       # @param [Hash] opts the options defining pool behavior.
-      # @option opts [Symbol] :overflow_policy (`:abort`) the overflow policy
+      # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
       #
       # @raise [ArgumentError] if `num_threads` is less than or equal to zero
-      # @raise [ArgumentError] if `overflow_policy` is not a known policy
+      # @raise [ArgumentError] if `fallback_policy` is not a known policy
       #
       # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
       def initialize(num_threads, opts = {})
@@ -24,16 +24,6 @@ if RUBY_PLATFORM == 'java'
         }.merge(opts)
         super(opts)
 
-
-        #@overflow_policy = opts.fetch(:overflow_policy, :abort)
-        #@max_queue = 0
-        #
-        #raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
-        #raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
-        #
-        #@executor = java.util.concurrent.Executors.newFixedThreadPool(num_threads)
-        #@executor.setRejectedExecutionHandler(OVERFLOW_POLICIES[@overflow_policy].new)
-
         set_shutdown_hook
       end
     end

data/lib/concurrent/executor/java_single_thread_executor.rb

@@ -10,11 +10,17 @@ if RUBY_PLATFORM == 'java'
 
       # Create a new thread pool.
       #
+      # @option opts [Symbol] :fallback_policy (:discard) the policy
+      #   for handling new tasks that are received when the queue size
+      #   has reached `max_queue` or after the executor has shut down
+      #
       # @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html
       # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html
       # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
       def initialize(opts = {})
         @executor = java.util.concurrent.Executors.newSingleThreadExecutor
+        @fallback_policy = opts.fetch(:fallback_policy, :discard)
+        raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.keys.include?(@fallback_policy)
         set_shutdown_hook
       end
     end

data/lib/concurrent/executor/java_thread_pool_executor.rb

@@ -20,26 +20,14 @@ if RUBY_PLATFORM == 'java'
       # before being reclaimed.
       DEFAULT_THREAD_IDLETIMEOUT = 60
 
-      # The set of possible overflow policies that may be set at thread pool creation.
-      OVERFLOW_POLICIES = {
-        abort: java.util.concurrent.ThreadPoolExecutor::AbortPolicy,
-        discard: java.util.concurrent.ThreadPoolExecutor::DiscardPolicy,
-        caller_runs: java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
-      }.freeze
-
       # The maximum number of threads that may be created in the pool.
       attr_reader :max_length
 
       # The maximum number of tasks that may be waiting in the work queue at any one time.
       # When the queue size reaches `max_queue` subsequent tasks will be rejected in
-      # accordance with the configured `overflow_policy`.
+      # accordance with the configured `fallback_policy`.
       attr_reader :max_queue
 
-      # The policy defining how rejected tasks (tasks received once the queue size reaches
-      # the configured `max_queue`) are handled. Must be one of the values specified in
-      # `OVERFLOW_POLICIES`.
-      attr_reader :overflow_policy
-
       # Create a new thread pool.
       #
       # @param [Hash] opts the options which configure the thread pool
@@ -52,14 +40,15 @@ if RUBY_PLATFORM == 'java'
       #   number of seconds a thread may be idle before being reclaimed
       # @option opts [Integer] :max_queue (DEFAULT_MAX_QUEUE_SIZE) the maximum
       #   number of tasks allowed in the work queue at any one time; a value of
-      #   zero means the queue may grow without bounnd
-      # @option opts [Symbol] :overflow_policy (:abort) the policy for handling new
-      #   tasks that are received when the queue size has reached `max_queue`
+      #   zero means the queue may grow without bound
+      # @option opts [Symbol] :fallback_policy (:abort) the policy for handling new
+      #   tasks that are received when the queue size has reached
+      #   `max_queue` or the executir has shut down
       #
       # @raise [ArgumentError] if `:max_threads` is less than one
       # @raise [ArgumentError] if `:min_threads` is less than zero
-      # @raise [ArgumentError] if `:overflow_policy` is not one of the values specified
-      #   in `OVERFLOW_POLICIES`
+      # @raise [ArgumentError] if `:fallback_policy` is not one of the values specified
+      #   in `FALLBACK_POLICIES`
       #
       # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html
       def initialize(opts = {})
@@ -67,12 +56,13 @@ if RUBY_PLATFORM == 'java'
         max_length = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
         idletime = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
         @max_queue = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i
-        @overflow_policy = opts.fetch(:overflow_policy, :abort)
+        @fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
+        warn '[DEPRECATED] :overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
 
         raise ArgumentError.new('max_threads must be greater than zero') if max_length <= 0
         raise ArgumentError.new('min_threads cannot be less than zero') if min_length < 0
         raise ArgumentError.new('min_threads cannot be more than max_threads') if min_length > max_length
-        raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+        raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
 
         if @max_queue == 0
           queue = java.util.concurrent.LinkedBlockingQueue.new
@@ -83,7 +73,7 @@ if RUBY_PLATFORM == 'java'
         @executor = java.util.concurrent.ThreadPoolExecutor.new(
           min_length, max_length,
           idletime, java.util.concurrent.TimeUnit::SECONDS,
-          queue, OVERFLOW_POLICIES[@overflow_policy].new)
+          queue, FALLBACK_POLICIES[@fallback_policy].new)
 
         set_shutdown_hook
       end

data/lib/concurrent/executor/ruby_cached_thread_pool.rb

@@ -8,18 +8,18 @@ module Concurrent
     # Create a new thread pool.
     #
     # @param [Hash] opts the options defining pool behavior.
-    #   number of seconds a thread may be idle before it is reclaimed
+    # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
     #
-    # @raise [ArgumentError] if `overflow_policy` is not a known policy
+    # @raise [ArgumentError] if `fallback_policy` is not a known policy
     def initialize(opts = {})
-      overflow_policy = opts.fetch(:overflow_policy, :abort)
+      fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
 
-      raise ArgumentError.new("#{overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.include?(overflow_policy)
+      raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(fallback_policy)
 
       opts = opts.merge(
         min_threads: 0,
         max_threads: DEFAULT_MAX_POOL_SIZE,
-        overflow_policy: overflow_policy,
+        fallback_policy: fallback_policy,
         max_queue: DEFAULT_MAX_QUEUE_SIZE,
         idletime: DEFAULT_THREAD_IDLETIMEOUT
       )

data/lib/concurrent/executor/ruby_fixed_thread_pool.rb

@@ -9,20 +9,20 @@ module Concurrent
     #
     # @param [Integer] num_threads the number of threads to allocate
     # @param [Hash] opts the options defining pool behavior.
-    # @option opts [Symbol] :overflow_policy (`:abort`) the overflow policy
+    # @option opts [Symbol] :fallback_policy (`:abort`) the fallback policy
     #
     # @raise [ArgumentError] if `num_threads` is less than or equal to zero
-    # @raise [ArgumentError] if `overflow_policy` is not a known policy
+    # @raise [ArgumentError] if `fallback_policy` is not a known policy
     def initialize(num_threads, opts = {})
-      overflow_policy = opts.fetch(:overflow_policy, :abort)
+      fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
 
       raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
-      raise ArgumentError.new("#{overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.include?(overflow_policy)
+      raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(fallback_policy)
 
       opts = {
         min_threads: num_threads,
         max_threads: num_threads,
-        overflow_policy: overflow_policy,
+        fallback_policy: fallback_policy,
         max_queue: DEFAULT_MAX_QUEUE_SIZE,
         idletime: DEFAULT_THREAD_IDLETIMEOUT,
       }.merge(opts)

data/lib/concurrent/executor/ruby_single_thread_executor.rb

@@ -9,12 +9,18 @@ module Concurrent
 
     # Create a new thread pool.
     #
+    # @option opts [Symbol] :fallback_policy (:discard) the policy for
+    #   handling new tasks that are received when the queue size has
+    #   reached `max_queue` or after the executor has shut down
+    #
     # @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html
     # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html
     # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
     def initialize(opts = {})
       @queue = Queue.new
       @thread = nil
+      @fallback_policy = opts.fetch(:fallback_policy, :discard)
+      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
       init_executor
     end
 

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -23,9 +23,6 @@ module Concurrent
     # before being reclaimed.
     DEFAULT_THREAD_IDLETIMEOUT = 60
 
-    # The set of possible overflow policies that may be set at thread pool creation.
-    OVERFLOW_POLICIES          = [:abort, :discard, :caller_runs]
-
     # The maximum number of threads that may be created in the pool.
     attr_reader :max_length
 
@@ -46,14 +43,9 @@ module Concurrent
 
     # The maximum number of tasks that may be waiting in the work queue at any one time.
     # When the queue size reaches `max_queue` subsequent tasks will be rejected in
-    # accordance with the configured `overflow_policy`.
+    # accordance with the configured `fallback_policy`.
     attr_reader :max_queue
 
-    # The policy defining how rejected tasks (tasks received once the queue size reaches
-    # the configured `max_queue`) are handled. Must be one of the values specified in
-    # `OVERFLOW_POLICIES`.
-    attr_reader :overflow_policy
-
     # Create a new thread pool.
     #
     # @param [Hash] opts the options which configure the thread pool
@@ -66,14 +58,15 @@ module Concurrent
     #   number of seconds a thread may be idle before being reclaimed
     # @option opts [Integer] :max_queue (DEFAULT_MAX_QUEUE_SIZE) the maximum
     #   number of tasks allowed in the work queue at any one time; a value of
-    #   zero means the queue may grow without bounnd
-    # @option opts [Symbol] :overflow_policy (:abort) the policy for handling new
-    #   tasks that are received when the queue size has reached `max_queue`
+    #   zero means the queue may grow without bound
+    # @option opts [Symbol] :fallback_policy (:abort) the policy for handling new
+    #   tasks that are received when the queue size has reached
+    #   `max_queue` or the executor has shut down
     #
     # @raise [ArgumentError] if `:max_threads` is less than one
     # @raise [ArgumentError] if `:min_threads` is less than zero
-    # @raise [ArgumentError] if `:overflow_policy` is not one of the values specified
-    #   in `OVERFLOW_POLICIES`
+    # @raise [ArgumentError] if `:fallback_policy` is not one of the values specified
+    #   in `FALLBACK_POLICIES`
     #
     # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html
     def initialize(opts = {})
@@ -81,11 +74,12 @@ module Concurrent
       @max_length      = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
       @idletime        = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
       @max_queue       = opts.fetch(:max_queue, DEFAULT_MAX_QUEUE_SIZE).to_i
-      @overflow_policy = opts.fetch(:overflow_policy, :abort)
+      @fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
+      warn '[DEPRECATED] :overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
 
       raise ArgumentError.new('max_threads must be greater than zero') if @max_length <= 0
       raise ArgumentError.new('min_threads cannot be less than zero') if @min_length < 0
-      raise ArgumentError.new("#{overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.include?(@overflow_policy)
+      raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
       raise ArgumentError.new('min_threads cannot be more than max_threads') if min_length > max_length
 
       init_executor
@@ -169,7 +163,7 @@ module Concurrent
         @scheduled_task_count += 1
         @queue << [args, task]
       else
-        handle_overflow(*args, &task) if @max_queue != 0 && @queue.length >= @max_queue
+        handle_fallback(*args, &task) if @max_queue != 0 && @queue.length >= @max_queue
       end
     end
 
@@ -224,29 +218,6 @@ module Concurrent
       capacity
     end
 
-    # Handler which executes the `overflow_policy` once the queue size
-    # reaches `max_queue`.
-    #
-    # @param [Array] args the arguments to the task which is being handled.
-    #
-    # @!visibility private
-    def handle_overflow(*args)
-      case @overflow_policy
-      when :abort
-        raise RejectedExecutionError
-      when :discard
-        false
-      when :caller_runs
-        begin
-          yield(*args)
-        rescue => ex
-          # let it fail
-          log DEBUG, ex
-        end
-        true
-      end
-    end
-
     # Scan all threads in the pool and reclaim any that are dead or
     # have been idle too long. Will check the last time the pool was
     # pruned and only run if the configured garbage collection

data/lib/concurrent/executor/ruby_thread_pool_worker.rb

@@ -13,6 +13,7 @@ module Concurrent
       @parent = parent
       @mutex = Mutex.new
       @last_activity = Time.now.to_f
+      @thread = nil
     end
 
     # @!visibility private

data/lib/concurrent/executor/serialized_execution.rb

@@ -12,7 +12,7 @@ module Concurrent
 
     Job = Struct.new(:executor, :args, :block) do
       def call
-        block.call *args
+        block.call(*args)
       end
     end
 

data/lib/concurrent/executor/thread_pool_executor.rb

@@ -40,17 +40,15 @@ module Concurrent
     #   * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
     #   * `max_queue`: The maximum number of tasks that may be waiting in the work queue at
     #     any one time. When the queue size reaches `max_queue` subsequent tasks will be
-    #     rejected in accordance with the configured `overflow_policy`.
-    #   * `overflow_policy`: The policy defining how rejected tasks are handled.    #
+    #     rejected in accordance with the configured `fallback_policy`.
+    #   * `fallback_policy`: The policy defining how rejected tasks are handled.    #
     #
-    #   Three overflow policies are supported:
+    #   Three fallback policies are supported:
     #
     #   * `:abort`: Raise a `RejectedExecutionError` exception and discard the task.
-    #   * `:discard`: Silently discard the task and return `nil` as the task result.
+    #   * `:discard`: Discard the task and return false.
     #   * `:caller_runs`: Execute the task on the calling thread.
     #
-    #   {include:file:doc/thread_pools.md}
-    #
     #   @note When running on the JVM (JRuby) this class will inherit from `JavaThreadPoolExecutor`.
     #     On all other platforms it will inherit from `RubyThreadPoolExecutor`.
     #

data/lib/concurrent/executor/timer_set.rb

@@ -55,10 +55,10 @@ module Concurrent
           @queue.push(Task.new(time, args, task))
           @timer_executor.post(&method(:process_tasks))
         end
-
-        true
       end
 
+      @condition.signal
+      true
     end
 
     # For a timer, #kill is like an orderly shutdown, except we need to manually
@@ -129,8 +129,20 @@ module Concurrent
         interval = task.time - Time.now.to_f
 
         if interval <= 0
+          # We need to remove the task from the queue before passing
+          # it to the executor, to avoid race conditions where we pass
+          # the peek'ed task to the executor and then pop a different
+          # one that's been added in the meantime.
+          #
+          # Note that there's no race condition between the peek and
+          # this pop - this pop could retrieve a different task from
+          # the peek, but that task would be due to fire now anyway
+          # (because @queue is a priority queue, and this thread is
+          # the only reader, so whatever timer is at the head of the
+          # queue now must have the same pop time, or a closer one, as
+          # when we peeked).
+          task = mutex.synchronize { @queue.pop }
           @task_executor.post(*task.args, &task.op)
-          mutex.synchronize { @queue.pop }
         else
           mutex.synchronize do
             @condition.wait(mutex, [interval, 60].min)

data/lib/concurrent/lazy_register.rb

@@ -49,7 +49,7 @@ module Concurrent
     # @return self
     # @param [Object] key
     def unregister(key)
-      @data.update { |h| h.dup.tap { |h| h.delete(key) } }
+      @data.update { |h| h.dup.tap { |j| j.delete(key) } }
       self
     end
 

data/lib/concurrent/observable.rb

@@ -46,7 +46,7 @@ module Concurrent
     # as #add_observer but it can be used for chaining
     # @return [Observable] self
     def with_observer(*args, &block)
-      add_observer *args, &block
+      add_observer(*args, &block)
       self
     end
 

data/lib/concurrent/promise.rb

@@ -5,7 +5,167 @@ require 'concurrent/options_parser'
 
 module Concurrent
 
-  # {include:file:doc/promise.md}
+  PromiseExecutionError = Class.new(StandardError)
+
+  # Promises are inspired by the JavaScript [Promises/A](http://wiki.commonjs.org/wiki/Promises/A)
+  # and [Promises/A+](http://promises-aplus.github.io/promises-spec/) specifications.
+  # 
+  # > A promise represents the eventual value returned from the single completion of an operation.
+  # 
+  # Promises are similar to futures and share many of the same behaviours. Promises are far more
+  # robust, however. Promises can be chained in a tree structure where each promise may have zero
+  # or more children. Promises are chained using the `then` method. The result of a call to `then`
+  # is always another promise. Promises are resolved asynchronously (with respect to the main thread)
+  # but in a strict order: parents are guaranteed to be resolved before their children, children
+  # before their younger siblings. The `then` method takes two parameters: an optional block to
+  # be executed upon parent resolution and an optional callable to be executed upon parent failure.
+  # The result of each promise is passed to each of its children upon resolution. When a promise
+  # is rejected all its children will be summarily rejected and will receive the reason. 
+  # 
+  # Promises have four possible states: *unscheduled*, *pending*, *rejected*, and *fulfilled*. A
+  # Promise created using `.new` will be *unscheduled*. It is scheduled by calling the `execute`
+  # method. Upon execution the Promise and all its children will be set to *pending*. When a promise
+  # is *pending* it will remain in that state until processing is complete. A completed Promise is
+  # either *rejected*, indicating that an exception was thrown during processing, or *fulfilled*,
+  # indicating it succeeded. If a Promise is *fulfilled* its `value` will be updated to reflect
+  # the result of the operation. If *rejected* the `reason` will be updated with a reference to
+  # the thrown exception. The predicate methods `unscheduled?`, `pending?`, `rejected?`, and
+  # `fulfilled?` can be called at any time to obtain the state of the Promise, as can the `state`
+  # method, which returns a symbol. A Promise created using `.execute` will be *pending*, a Promise
+  # created using `.fulfill(value)` will be *fulfilled* with the given value and a Promise created
+  # using `.reject(reason)` will be *rejected* with the given reason. 
+  # 
+  # Retrieving the value of a promise is done through the `value` (alias: `deref`) method. Obtaining
+  # the value of a promise is a potentially blocking operation. When a promise is *rejected* a call
+  # to `value` will return `nil` immediately. When a promise is *fulfilled* a call to `value` will
+  # immediately return the current value. When a promise is *pending* a call to `value` will block
+  # until the promise is either *rejected* or *fulfilled*. A *timeout* value can be passed to `value`
+  # to limit how long the call will block. If `nil` the call will block indefinitely. If `0` the call
+  # will not block. Any other integer or float value will indicate the maximum number of seconds to block. 
+  # 
+  # Promises run on the global thread pool.
+  # 
+  # ### Examples
+  # 
+  # Start by requiring promises
+  # 
+  # ```ruby
+  # require 'concurrent'
+  # ```
+  # 
+  # Then create one
+  # 
+  # ```ruby
+  # p = Concurrent::Promise.execute do
+  #       # do something
+  #       42
+  #     end
+  # ```
+  # 
+  # Promises can be chained using the `then` method. The `then` method accepts a block, to be executed
+  # on fulfillment, and a callable argument to be executed on rejection. The result of the each promise
+  # is passed as the block argument to chained promises. 
+  # 
+  # ```ruby
+  # p = Concurrent::Promise.new{10}.then{|x| x * 2}.then{|result| result - 10 }.execute
+  # ```
+  # 
+  # And so on, and so on, and so on...
+  # 
+  # ```ruby
+  # p = Concurrent::Promise.fulfill(20).
+  #     then{|result| result - 10 }.
+  #     then{|result| result * 3 }.
+  #     then{|result| result % 5 }.execute
+  # ```
+  # 
+  # The initial state of a newly created Promise depends on the state of its parent:
+  # - if parent is *unscheduled* the child will be *unscheduled*
+  # - if parent is *pending* the child will be *pending*
+  # - if parent is *fulfilled* the child will be *pending*
+  # - if parent is *rejected* the child will be *pending* (but will ultimately be *rejected*)
+  # 
+  # Promises are executed asynchronously from the main thread. By the time a child Promise finishes 
+  # nitialization it may be in a different state that its parent (by the time a child is created its parent
+  # may have completed execution and changed state). Despite being asynchronous, however, the order of
+  # execution of Promise objects in a chain (or tree) is strictly defined. 
+  # 
+  # There are multiple ways to create and execute a new `Promise`. Both ways provide identical behavior:
+  # 
+  # ```ruby
+  # # create, operate, then execute
+  # p1 = Concurrent::Promise.new{ "Hello World!" }
+  # p1.state #=> :unscheduled
+  # p1.execute
+  # 
+  # # create and immediately execute
+  # p2 = Concurrent::Promise.new{ "Hello World!" }.execute
+  # 
+  # # execute during creation
+  # p3 = Concurrent::Promise.execute{ "Hello World!" }
+  # ```
+  # 
+  # Once the `execute` method is called a `Promise` becomes `pending`:
+  # 
+  # ```ruby
+  # p = Concurrent::Promise.execute{ "Hello, world!" }
+  # p.state    #=> :pending
+  # p.pending? #=> true
+  # ```
+  # 
+  # Wait a little bit, and the promise will resolve and provide a value:
+  # 
+  # ```ruby
+  # p = Concurrent::Promise.execute{ "Hello, world!" }
+  # sleep(0.1)
+  # 
+  # p.state      #=> :fulfilled
+  # p.fulfilled? #=> true
+  # p.value      #=> "Hello, world!"
+  # ```
+  # 
+  # If an exception occurs, the promise will be rejected and will provide
+  # a reason for the rejection:
+  # 
+  # ```ruby
+  # p = Concurrent::Promise.execute{ raise StandardError.new("Here comes the Boom!") }
+  # sleep(0.1)
+  # 
+  # p.state     #=> :rejected
+  # p.rejected? #=> true
+  # p.reason    #=> "#<StandardError: Here comes the Boom!>"
+  # ```
+  # 
+  # #### Rejection
+  # 
+  # When a promise is rejected all its children will be rejected and will receive the rejection `reason`
+  # as the rejection callable parameter:
+  # 
+  # ```ruby
+  # p = [ Concurrent::Promise.execute{ Thread.pass; raise StandardError } ]
+  # 
+  # c1 = p.then(Proc.new{ |reason| 42 })
+  # c2 = p.then(Proc.new{ |reason| raise 'Boom!' })
+  # 
+  # sleep(0.1)
+  # 
+  # c1.state  #=> :rejected
+  # c2.state  #=> :rejected
+  # ```
+  # 
+  # Once a promise is rejected it will continue to accept children that will receive immediately rejection
+  # (they will be executed asynchronously).
+  # 
+  # #### Aliases
+  # 
+  # The `then` method is the most generic alias: it accepts a block to be executed upon parent fulfillment
+  # and a callable to be executed upon parent rejection. At least one of them should be passed. The default
+  # block is `{ |result| result }` that fulfills the child with the parent value. The default callable is
+  # `{ |reason| raise reason }` that rejects the child with the parent reason. 
+  # 
+  # - `on_success { |result| ... }` is the same as `then {|result| ... }`
+  # - `rescue { |reason| ... }` is the same as `then(Proc.new { |reason| ... } )`
+  # - `rescue` is aliased by `catch` and `on_error`
   class Promise
     # TODO unify promise and future to single class, with dataflow
     include Obligation
@@ -44,6 +204,7 @@ module Concurrent
       @children = []
 
       init_obligation
+      set_deref_options(opts)
     end
 
     # @return [Promise]
@@ -100,7 +261,7 @@ module Concurrent
     # @return [Promise]
     def on_success(&block)
       raise ArgumentError.new('no block given') unless block_given?
-      self.then &block
+      self.then(&block)
     end
 
     # @return [Promise]
@@ -168,8 +329,66 @@ module Concurrent
       self.class.zip(self, *others)
     end
 
+    # Aggregates a collection of promises and executes the `then` condition
+    # if all aggregated promises succeed. Executes the `rescue` handler with
+    # a `Concurrent::PromiseExecutionError` if any of the aggregated promises
+    # fail. Upon execution will execute any of the aggregate promises that
+    # were not already executed.
+    #
+    # @!macro [attach] promise_self_aggregate
+    #
+    #   The returned promise will not yet have been executed. Additional `#then`
+    #   and `#rescue` handlers may still be provided. Once the returned promise
+    #   is execute the aggregate promises will be also be executed (if they have
+    #   not been executed already). The results of the aggregate promises will
+    #   be checked upon completion. The necessary `#then` and `#rescue` blocks
+    #   on the aggregating promise will then be executed as appropriate. If the
+    #   `#rescue` handlers are executed the raises exception will be
+    #   `Concurrent::PromiseExecutionError`.
+    #
+    #   @param [Array] promises Zero or more promises to aggregate
+    #   @return [Promise] an unscheduled (not executed) promise that aggregates
+    #     the promises given as arguments
+    def self.all?(*promises)
+      aggregate(:all?, *promises)
+    end
+
+    # Aggregates a collection of promises and executes the `then` condition
+    # if any aggregated promises succeed. Executes the `rescue` handler with
+    # a `Concurrent::PromiseExecutionError` if any of the aggregated promises
+    # fail. Upon execution will execute any of the aggregate promises that
+    # were not already executed.
+    #
+    # @!macro promise_self_aggregate
+    def self.any?(*promises)
+      aggregate(:any?, *promises)
+    end
+
     protected
 
+    # Aggregate a collection of zero or more promises under a composite promise,
+    # execute the aggregated promises and collect them into a standard Ruby array,
+    # call the given Ruby `Ennnumerable` predicate (such as `any?`, `all?`, `none?`,
+    # or `one?`) on the collection checking for the success or failure of each,
+    # then executing the composite's `#then` handlers if the predicate returns
+    # `true` or executing the composite's `#rescue` handlers if the predicate
+    # returns false.
+    #
+    # @!macro promise_self_aggregate
+    def self.aggregate(method, *promises)
+      composite = Promise.new do
+        completed = promises.collect do |promise|
+          promise.execute if promise.unscheduled?
+          promise.wait
+          promise
+        end
+        unless completed.empty? || completed.send(method){|promise| promise.fulfilled? }
+          raise PromiseExecutionError
+        end
+      end
+      composite
+    end
+
     def set_pending
       mutex.synchronize do
         @state = :pending

data/lib/concurrent/scheduled_task.rb

@@ -26,7 +26,7 @@ module Concurrent
     def execute
       if compare_and_set_state(:pending, :unscheduled)
         @schedule_time = TimerSet.calculate_schedule_time(@intended_time)
-        Concurrent::timer(@schedule_time.to_f - Time.now.to_f) { @executor.post &method(:process_task) }
+        Concurrent::timer(@schedule_time.to_f - Time.now.to_f) { @executor.post(&method(:process_task)) }
         self
       end
     end

data/lib/concurrent/timer_task.rb

@@ -317,7 +317,7 @@ module Concurrent
     def execute_task(completion)
       return unless @running.true?
       Concurrent::timer(execution_interval, completion, &method(:timeout_task))
-      success, value, reason = @executor.execute(self)
+      _success, value, reason = @executor.execute(self)
       if completion.try?
         self.value = value
         schedule_next_task

data/lib/concurrent/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.2
 platform: x86-linux
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-12-05 00:00:00.000000000 Z
+date: 2015-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ref
@@ -92,6 +92,7 @@ files:
 - lib/concurrent/atomic/count_down_latch.rb
 - lib/concurrent/atomic/cyclic_barrier.rb
 - lib/concurrent/atomic/event.rb
+- lib/concurrent/atomic/semaphore.rb
 - lib/concurrent/atomic/synchronization.rb
 - lib/concurrent/atomic/thread_local_var.rb
 - lib/concurrent/atomic_reference/concurrent_update_error.rb
@@ -178,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.4
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,