concurrent-ruby 1.0.5 → 1.1.1

data/lib/concurrent/collection/lock_free_stack.rb

@@ -0,0 +1,158 @@
+module Concurrent
+
+  # @!macro warn.edge
+  class LockFreeStack < Synchronization::Object
+
+    safe_initialization!
+
+    class Node
+      # TODO (pitr-ch 20-Dec-2016): Could be unified with Stack class?
+
+      # @return [Node]
+      attr_reader :next_node
+
+      # @return [Object]
+      attr_reader :value
+
+      # @!visibility private
+      # allow to nil-ify to free GC when the entry is no longer relevant, not synchronised
+      attr_writer :value
+
+      def initialize(value, next_node)
+        @value     = value
+        @next_node = next_node
+      end
+
+      singleton_class.send :alias_method, :[], :new
+    end
+
+    # The singleton for empty node
+    EMPTY = Node[nil, nil]
+    def EMPTY.next_node
+      self
+    end
+
+    attr_atomic(:head)
+    private :head, :head=, :swap_head, :compare_and_set_head, :update_head
+
+    # @!visibility private
+    def self.of1(value)
+      new Node[value, EMPTY]
+    end
+
+    # @!visibility private
+    def self.of2(value1, value2)
+      new Node[value1, Node[value2, EMPTY]]
+    end
+
+    # @param [Node] head
+    def initialize(head = EMPTY)
+      super()
+      self.head = head
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def empty?(head = self.head)
+      head.equal? EMPTY
+    end
+
+    # @param [Node] head
+    # @param [Object] value
+    # @return [true, false]
+    def compare_and_push(head, value)
+      compare_and_set_head head, Node[value, head]
+    end
+
+    # @param [Object] value
+    # @return [self]
+    def push(value)
+      while true
+        current_head = head
+        return self if compare_and_set_head current_head, Node[value, current_head]
+      end
+    end
+
+    # @return [Node]
+    def peek
+      head
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def compare_and_pop(head)
+      compare_and_set_head head, head.next_node
+    end
+
+    # @return [Object]
+    def pop
+      while true
+        current_head = head
+        return current_head.value if compare_and_set_head current_head, current_head.next_node
+      end
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def compare_and_clear(head)
+      compare_and_set_head head, EMPTY
+    end
+
+    include Enumerable
+
+    # @param [Node] head
+    # @return [self]
+    def each(head = nil)
+      return to_enum(:each, head) unless block_given?
+      it = head || peek
+      until it.equal?(EMPTY)
+        yield it.value
+        it = it.next_node
+      end
+      self
+    end
+
+    # @return [true, false]
+    def clear
+      while true
+        current_head = head
+        return false if current_head == EMPTY
+        return true if compare_and_set_head current_head, EMPTY
+      end
+    end
+
+    # @param [Node] head
+    # @return [true, false]
+    def clear_if(head)
+      compare_and_set_head head, EMPTY
+    end
+
+    # @param [Node] head
+    # @param [Node] new_head
+    # @return [true, false]
+    def replace_if(head, new_head)
+      compare_and_set_head head, new_head
+    end
+
+    # @return [self]
+    # @yield over the cleared stack
+    # @yieldparam [Object] value
+    def clear_each(&block)
+      while true
+        current_head = head
+        return self if current_head == EMPTY
+        if compare_and_set_head current_head, EMPTY
+          each current_head, &block
+          return self
+        end
+      end
+    end
+
+    # @return [String] Short string representation.
+    def to_s
+      format '%s %s>', super[0..-2], to_a.to_s
+    end
+
+    alias_method :inspect, :to_s
+  end
+end

data/lib/concurrent/collection/map/atomic_reference_map_backend.rb

@@ -289,7 +289,7 @@ module Concurrent
                   end
                 end
               elsif cas_hash(my_hash, my_hash | WAITING)
-                force_aquire_lock(table, i)
+                force_acquire_lock(table, i)
                 break
               end
             end
@@ -330,7 +330,7 @@ module Concurrent
         end
 
         private
-        def force_aquire_lock(table, i)
+        def force_acquire_lock(table, i)
           cheap_synchronize do
             if equal?(table.volatile_get(i)) && (hash & WAITING) == WAITING
               cheap_wait
@@ -831,7 +831,7 @@ module Concurrent
             # no lock needed (or available) if bin >= 0, because we're not popping values from locked_indexes until we've run through the whole table
             redo unless (bin >= 0 ? table.cas(i, nil, forwarder) : lock_and_clean_up_reverse_forwarders(table, old_table_size, new_table, i, forwarder))
           elsif Node.locked_hash?(node_hash = node.hash)
-            locked_indexes ||= Array.new
+            locked_indexes ||= ::Array.new
             if bin < 0 && locked_arr_idx > 0
               locked_arr_idx -= 1
               i, locked_indexes[locked_arr_idx] = locked_indexes[locked_arr_idx], i # swap with another bin

data/lib/concurrent/collection/map/non_concurrent_map_backend.rb

@@ -10,7 +10,7 @@ module Concurrent
 
       # WARNING: all public methods of the class must operate on the @backend
       # directly without calling each other. This is important because of the
-      # SynchronizedMapBackend which uses a non-reentrant mutex for perfomance
+      # SynchronizedMapBackend which uses a non-reentrant mutex for performance
       # reasons.
       def initialize(options = nil)
         @backend = {}
@@ -95,7 +95,6 @@ module Concurrent
       end
 
       def each_pair
-        return enum_for :each_pair unless block_given?
         dupped_backend.each_pair do |k, v|
           yield k, v
         end

data/lib/concurrent/collection/non_concurrent_priority_queue.rb

@@ -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/concern/dereferenceable.rb

@@ -32,7 +32,7 @@ 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).
       #

data/lib/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/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/configuration.rb

@@ -175,13 +175,8 @@ module Concurrent
   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
     )
   end

data/lib/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/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/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/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

data/lib/concurrent/executor/abstract_executor_service.rb

@@ -93,7 +93,7 @@ module Concurrent
       raise NotImplementedError
     end
 
-    # @!macro [attach] executor_service_method_ns_shutdown_execution
+    # @!macro executor_service_method_ns_shutdown_execution
     #
     #   Callback method called when an orderly shutdown has completed.
     #   The default behavior is to signal all waiting threads.
@@ -101,7 +101,7 @@ module Concurrent
       # do nothing
     end
 
-    # @!macro [attach] executor_service_method_ns_kill_execution
+    # @!macro executor_service_method_ns_kill_execution
     #
     #   Callback method called when the executor has been killed.
     #   The default behavior is to do nothing.

data/lib/concurrent/executor/cached_thread_pool.rb

@@ -26,7 +26,7 @@ module Concurrent
   # @!macro thread_pool_options
   class CachedThreadPool < ThreadPoolExecutor
 
-    # @!macro [attach] cached_thread_pool_method_initialize
+    # @!macro cached_thread_pool_method_initialize
     #
     #   Create a new thread pool.
     #