concurrent-ruby 1.0.5 → 1.1.10

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/non_concurrent_priority_queue.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/collection/java_non_concurrent_priority_queue'
 require 'concurrent/collection/ruby_non_concurrent_priority_queue'
-require 'concurrent/utility/engine'
 
 module Concurrent
   module Collection
@@ -15,7 +15,7 @@ module Concurrent
                                                end
     private_constant :NonConcurrentPriorityQueueImplementation
 
-    # @!macro [attach] priority_queue
+    # @!macro priority_queue
     #
     #   A queue collection in which the elements are sorted based on their
     #   comparison (spaceship) operator `<=>`. Items are added to the queue
@@ -45,7 +45,7 @@ module Concurrent
     #   @see http://algs4.cs.princeton.edu/24pq/MaxPQ.java.html
     #
     #   @see http://docs.oracle.com/javase/7/docs/api/java/util/PriorityQueue.html
-    # 
+    #
     # @!visibility private
     class NonConcurrentPriorityQueue < NonConcurrentPriorityQueueImplementation
 
@@ -60,83 +60,83 @@ module Concurrent
       alias_method :enq, :push
 
       # @!method initialize(opts = {})
-      #   @!macro [new] priority_queue_method_initialize
+      #   @!macro priority_queue_method_initialize
       #
       #     Create a new priority queue with no items.
-      #    
+      #
       #     @param [Hash] opts the options for creating the queue
       #     @option opts [Symbol] :order (:max) dictates the order in which items are
       #       stored: from highest to lowest when `:max` or `:high`; from lowest to
       #       highest when `:min` or `:low`
 
       # @!method clear
-      #   @!macro [new] priority_queue_method_clear
+      #   @!macro priority_queue_method_clear
       #
       #     Removes all of the elements from this priority queue.
 
       # @!method delete(item)
-      #   @!macro [new] priority_queue_method_delete
+      #   @!macro priority_queue_method_delete
       #
       #     Deletes all items from `self` that are equal to `item`.
-      #  
+      #
       #     @param [Object] item the item to be removed from the queue
       #     @return [Object] true if the item is found else false
 
       # @!method empty?
-      #   @!macro [new] priority_queue_method_empty
-      #  
+      #   @!macro priority_queue_method_empty
+      #
       #     Returns `true` if `self` contains no elements.
-      #  
+      #
       #     @return [Boolean] true if there are no items in the queue else false
 
       # @!method include?(item)
-      #   @!macro [new] priority_queue_method_include
+      #   @!macro priority_queue_method_include
       #
       #     Returns `true` if the given item is present in `self` (that is, if any
       #     element == `item`), otherwise returns false.
-      #  
+      #
       #     @param [Object] item the item to search for
-      #  
+      #
       #     @return [Boolean] true if the item is found else false
 
       # @!method length
-      #   @!macro [new] priority_queue_method_length
-      #    
+      #   @!macro priority_queue_method_length
+      #
       #     The current length of the queue.
-      #    
+      #
       #     @return [Fixnum] the number of items in the queue
 
       # @!method peek
-      #   @!macro [new] priority_queue_method_peek
-      #    
+      #   @!macro priority_queue_method_peek
+      #
       #     Retrieves, but does not remove, the head of this queue, or returns `nil`
       #     if this queue is empty.
-      #     
+      #
       #     @return [Object] the head of the queue or `nil` when empty
 
       # @!method pop
-      #   @!macro [new] priority_queue_method_pop
-      #    
+      #   @!macro priority_queue_method_pop
+      #
       #     Retrieves and removes the head of this queue, or returns `nil` if this
       #     queue is empty.
-      #     
+      #
       #     @return [Object] the head of the queue or `nil` when empty
 
       # @!method push(item)
-      #   @!macro [new] priority_queue_method_push
-      #    
+      #   @!macro priority_queue_method_push
+      #
       #     Inserts the specified element into this priority queue.
-      #    
+      #
       #     @param [Object] item the item to insert onto the queue
 
       # @!method self.from_list(list, opts = {})
-      #   @!macro [new] priority_queue_method_from_list
-      #    
+      #   @!macro priority_queue_method_from_list
+      #
       #     Create a new priority queue from the given list.
-      #    
+      #
       #     @param [Enumerable] list the list to build the queue from
       #     @param [Hash] opts the options for creating the queue
-      #    
+      #
       #     @return [NonConcurrentPriorityQueue] the newly created and populated queue
     end
   end

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/ruby_non_concurrent_priority_queue.rb

@@ -30,7 +30,7 @@ module Concurrent
           if @queue[k] == item
             swap(k, @length)
             @length -= 1
-            sink(k)
+            sink(k) || swim(k)
             @queue.pop
           else
             k += 1
@@ -126,12 +126,17 @@ module Concurrent
       # 
       # @!visibility private
       def sink(k)
+        success = false
+
         while (j = (2 * k)) <= @length do
           j += 1 if j < @length && ! ordered?(j, j+1)
           break if ordered?(k, j)
           swap(k, j)
+          success = true
           k = j
         end
+
+        success
       end
 
       # Percolate up to maintain heap invariant.
@@ -140,10 +145,15 @@ module Concurrent
       # 
       # @!visibility private
       def swim(k)
+        success = false
+
         while k > 1 && ! ordered?(k/2, k) do
           swap(k, k/2)
           k = k/2
+          success = true
         end
+
+        success
       end
     end
   end

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/dereferenceable.rb

@@ -32,13 +32,13 @@ module Concurrent
         synchronize{ @value = value }
       end
 
-      # @!macro [attach] dereferenceable_set_deref_options
+      # @!macro dereferenceable_set_deref_options
       #   Set the options which define the operations #value performs before
       #   returning data to the caller (dereferencing).
       #
       #   @note Most classes that include this module will call `#set_deref_options`
-      #   from within the constructor, thus allowing these options to be set at
-      #   object creation.
+      #     from within the constructor, thus allowing these options to be set at
+      #     object creation.
       #
       #   @param [Hash] opts the options defining dereference behavior.
       #   @option opts [String] :dup_on_deref (false) call `#dup` before returning the data

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/logging.rb

@@ -17,7 +17,12 @@ module Concurrent
       def log(level, progname, message = nil, &block)
         #NOTE: Cannot require 'concurrent/configuration' above due to circular references.
         #      Assume that the gem has been initialized if we've gotten this far.
-        (@logger || Concurrent.global_logger).call level, progname, message, &block
+        logger = if defined?(@logger) && @logger
+                   @logger
+                 else
+                   Concurrent.global_logger
+                 end
+        logger.call level, progname, message, &block
       rescue => error
         $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
           "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/observable.rb

@@ -49,7 +49,7 @@ module Concurrent
     # or an AtomicFixum)
     module Observable
 
-      # @!macro [attach] observable_add_observer
+      # @!macro observable_add_observer
       #
       #   Adds an observer to this set. If a block is passed, the observer will be
       #   created by this method and no other params should be passed.
@@ -72,8 +72,8 @@ module Concurrent
         self
       end
 
-      # @!macro [attach] observable_delete_observer
-      # 
+      # @!macro observable_delete_observer
+      #
       #   Remove `observer` as an observer on this object so that it will no
       #   longer receive notifications.
       #
@@ -83,17 +83,17 @@ module Concurrent
         observers.delete_observer(observer)
       end
 
-      # @!macro [attach] observable_delete_observers
-      # 
+      # @!macro observable_delete_observers
+      #
       #   Remove all observers associated with this object.
-      #   
+      #
       #   @return [Observable] self
       def delete_observers
         observers.delete_observers
         self
       end
 
-      # @!macro [attach] observable_count_observers
+      # @!macro observable_count_observers
       #
       #   Return the number of observers associated with this object.
       #

data/lib/{concurrent → concurrent-ruby/concurrent}/configuration.rb

@@ -3,12 +3,14 @@ require 'concurrent/delay'
 require 'concurrent/errors'
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/concern/logging'
+require 'concurrent/concern/deprecation'
 require 'concurrent/executor/immediate_executor'
-require 'concurrent/utility/at_exit'
+require 'concurrent/executor/cached_thread_pool'
 require 'concurrent/utility/processor_counter'
 
 module Concurrent
   extend Concern::Logging
+  extend Concern::Deprecation
 
   autoload :Options, 'concurrent/options'
   autoload :TimerSet, 'concurrent/executor/timer_set'
@@ -96,15 +98,15 @@ module Concurrent
   end
 
   # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
+  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor }
   private_constant :GLOBAL_FAST_EXECUTOR
 
   # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
+  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor }
   private_constant :GLOBAL_IO_EXECUTOR
 
   # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new }
   private_constant :GLOBAL_TIMER_SET
 
   # @!visibility private
@@ -114,7 +116,7 @@ module Concurrent
   # Disables AtExit handlers including pool auto-termination handlers.
   # When disabled it will be the application programmer's responsibility
   # to ensure that the handlers are shutdown properly prior to application
-  # exit by calling {AtExit.run} method.
+  # exit by calling `AtExit.run` method.
   #
   # @note this option should be needed only because of `at_exit` ordering
   #   issues which may arise when running some of the testing frameworks.
@@ -124,9 +126,10 @@ module Concurrent
   # @note This method should *never* be called
   #   from within a gem. It should *only* be used from within the main
   #   application and even then it should be used only when necessary.
-  # @see AtExit
+  # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
+  #
   def self.disable_at_exit_handlers!
-    AtExit.enabled = false
+    deprecated "Method #disable_at_exit_handlers! has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841."
   end
 
   # Global thread pool optimized for short, fast *operations*.
@@ -170,19 +173,16 @@ module Concurrent
         auto_terminate:  opts.fetch(:auto_terminate, true),
         idletime:        60, # 1 minute
         max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "fast"
     )
   end
 
   def self.new_io_executor(opts = {})
-    ThreadPoolExecutor.new(
-        min_threads:     [2, Concurrent.processor_count].max,
-        max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
-        # max_threads:     1000,
+    CachedThreadPool.new(
         auto_terminate:  opts.fetch(:auto_terminate, true),
-        idletime:        60, # 1 minute
-        max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "io"
     )
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/constants.rb

@@ -3,6 +3,6 @@ module Concurrent
   # Various classes within allows for +nil+ values to be stored,
   # so a special +NULL+ token is required to indicate the "nil-ness".
   # @!visibility private
-  NULL = Object.new
+  NULL = ::Object.new
 
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/dataflow.rb

@@ -18,7 +18,8 @@ module Concurrent
     end
   end
 
-  # {include:file:doc/dataflow.md}
+  # Dataflow allows you to create a task that will be scheduled when all of its data dependencies are available.
+  # {include:file:docs-source/dataflow.md}
   #
   # @param [Future] inputs zero or more `Future` operations that this dataflow depends upon
   #

data/lib/{concurrent → concurrent-ruby/concurrent}/delay.rb

@@ -32,7 +32,7 @@ module Concurrent
   #
   # @!macro copy_options
   #
-  # @!macro [attach] delay_note_regarding_blocking
+  # @!macro delay_note_regarding_blocking
   #   @note The default behavior of `Delay` is to block indefinitely when
   #     calling either `value` or `wait`, executing the delayed operation on
   #     the current thread. This makes the `timeout` value completely
@@ -81,13 +81,15 @@ module Concurrent
         # this function has been optimized for performance and
         # should not be modified without running new benchmarks
         synchronize do
-          execute = @computing = true unless @computing
+          execute = @evaluation_started = true unless @evaluation_started
           if execute
             begin
               set_state(true, @task.call, nil)
             rescue => ex
               set_state(false, nil, ex)
             end
+          elsif incomplete?
+            raise IllegalOperationError, 'Recursive call to #value during evaluation of the Delay'
           end
         end
         if @do_nothing_on_deref
@@ -144,7 +146,7 @@ module Concurrent
     def reconfigure(&block)
       synchronize do
         raise ArgumentError.new('no block given') unless block_given?
-        unless @computing
+        unless @evaluation_started
           @task = block
           true
         else
@@ -160,9 +162,9 @@ module Concurrent
       set_deref_options(opts)
       @executor = opts[:executor]
 
-      @task      = block
-      @state     = :pending
-      @computing = false
+      @task               = block
+      @state              = :pending
+      @evaluation_started = false
     end
 
     private
@@ -173,7 +175,7 @@ module Concurrent
       # should not be modified without running new benchmarks
       execute = task = nil
       synchronize do
-        execute = @computing = true unless @computing
+        execute = @evaluation_started = true unless @evaluation_started
         task    = @task
       end
 

data/lib/{concurrent → concurrent-ruby/concurrent}/exchanger.rb

@@ -8,7 +8,7 @@ require 'concurrent/utility/monotonic_time'
 
 module Concurrent
 
-  # @!macro [attach] exchanger
+  # @!macro exchanger
   #
   #   A synchronization point at which threads can pair and swap elements within
   #   pairs. Each thread presents some object on entry to the exchange method,
@@ -24,9 +24,6 @@ module Concurrent
   #   will remain correct.
   #
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Exchanger.html java.util.concurrent.Exchanger
-  #
-  #   @!macro edge_warning
-  #
   #   @example
   #
   #     exchanger = Concurrent::Exchanger.new
@@ -36,20 +33,19 @@ module Concurrent
   #       Thread.new { puts "second: " << exchanger.exchange('bar', 1) } #=> "second: foo"
   #     ]
   #     threads.each {|t| t.join(2) }
-  #
+
   # @!visibility private
   class AbstractExchanger < Synchronization::Object
 
     # @!visibility private
-    CANCEL = Object.new
+    CANCEL = ::Object.new
     private_constant :CANCEL
 
-    # @!macro [attach] exchanger_method_initialize
     def initialize
       super
     end
 
-    # @!macro [attach] exchanger_method_do_exchange
+    # @!macro exchanger_method_do_exchange
     #
     #   Waits for another thread to arrive at this exchange point (unless the
     #   current thread is interrupted), and then transfers the given object to
@@ -61,7 +57,7 @@ module Concurrent
     #   @param [Object] value the value to exchange with another thread
     #   @param [Numeric, nil] timeout in seconds, `nil` blocks indefinitely
     #
-    # @!macro [attach] exchanger_method_exchange
+    # @!macro exchanger_method_exchange
     #
     #   In some edge cases when a `timeout` is given a return value of `nil` may be
     #   ambiguous. Specifically, if `nil` is a valid value in the exchange it will
@@ -75,8 +71,7 @@ module Concurrent
     end
 
     # @!macro exchanger_method_do_exchange
-    #
-    # @!macro [attach] exchanger_method_exchange_bang
+    # @!macro exchanger_method_exchange_bang
     #
     #   On timeout a {Concurrent::TimeoutError} exception will be raised.
     #
@@ -91,8 +86,7 @@ module Concurrent
     end
 
     # @!macro exchanger_method_do_exchange
-    #
-    # @!macro [attach] exchanger_method_try_exchange
+    # @!macro exchanger_method_try_exchange
     #
     #   The return value will be a {Concurrent::Maybe} set to `Just` on success or
     #   `Nothing` on timeout.
@@ -130,7 +124,6 @@ module Concurrent
     end
   end
 
-  # @!macro exchanger
   # @!macro internal_implementation_note
   # @!visibility private
   class RubyExchanger < AbstractExchanger
@@ -148,8 +141,8 @@ module Concurrent
 
       def initialize(item)
         super()
-        @Item = item
-        @Latch = Concurrent::CountDownLatch.new
+        @Item      = item
+        @Latch     = Concurrent::CountDownLatch.new
         self.value = nil
       end
 
@@ -163,7 +156,6 @@ module Concurrent
     end
     private_constant :Node
 
-    # @!macro exchanger_method_initialize
     def initialize
       super
     end
@@ -218,7 +210,7 @@ module Concurrent
       # node's initial value. It never changes. It's what the fulfiller returns on
       # success. The occupier's hole is where the fulfiller put its item. It's the
       # item that the occupier returns on success. The latch is used for synchronization.
-      # Becuase a thread may act as either an occupier or fulfiller (or possibly
+      # Because a thread may act as either an occupier or fulfiller (or possibly
       # both in periods of high contention) every thread creates a node when
       # the exchange method is first called.
       #
@@ -260,8 +252,8 @@ module Concurrent
       #     - Wake the sleeping occupier
       #     - Return the occupier's item
 
-      value = NULL if value.nil?                        # The sentinel allows nil to be a valid value
-      me = Node.new(value)                              # create my node in case I need to occupy
+      value  = NULL if value.nil? # The sentinel allows nil to be a valid value
+      me     = Node.new(value) # create my node in case I need to occupy
       end_at = Concurrent.monotonic_time + timeout.to_f # The time to give up
 
       result = loop do
@@ -298,12 +290,10 @@ module Concurrent
 
   if Concurrent.on_jruby?
 
-    # @!macro exchanger
     # @!macro internal_implementation_note
     # @!visibility private
     class JavaExchanger < AbstractExchanger
 
-      # @!macro exchanger_method_initialize
       def initialize
         @exchanger = java.util.concurrent.Exchanger.new
       end
@@ -314,11 +304,17 @@ module Concurrent
       #
       # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
       def do_exchange(value, timeout)
+        result = nil
         if timeout.nil?
-          @exchanger.exchange(value)
+          Synchronization::JRuby.sleep_interruptibly do
+            result = @exchanger.exchange(value)
+          end
         else
-          @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          Synchronization::JRuby.sleep_interruptibly do
+            result = @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          end
         end
+        result
       rescue java.util.concurrent.TimeoutException
         CANCEL
       end
@@ -339,7 +335,7 @@ module Concurrent
   class Exchanger < ExchangerImplementation
 
     # @!method initialize
-    #   @!macro exchanger_method_initialize
+    #   Creates exchanger instance
 
     # @!method exchange(value, timeout = nil)
     #   @!macro exchanger_method_do_exchange