concurrent-ruby 1.0.5 → 1.1.0.pre1

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
@@ -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.
       #
@@ -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
@@ -315,9 +305,11 @@ module Concurrent
       # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
       def do_exchange(value, timeout)
         if timeout.nil?
-          @exchanger.exchange(value)
+          Synchronization::JRuby.sleep_interruptibly { @exchanger.exchange(value) }
         else
-          @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          Synchronization::JRuby.sleep_interruptibly do
+            @exchanger.exchange(value, 1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
+          end
         end
       rescue java.util.concurrent.TimeoutException
         CANCEL
@@ -339,7 +331,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.
     #

data/lib/concurrent/executor/executor_service.rb

@@ -4,7 +4,7 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] executor_service_method_post
+  # @!macro executor_service_method_post
   #
   #   Submit a task to the executor for asynchronous processing.
   #
@@ -17,7 +17,7 @@ module Concurrent
   #
   #   @raise [ArgumentError] if no task is given
 
-  # @!macro [new] executor_service_method_left_shift
+  # @!macro executor_service_method_left_shift
   #
   #   Submit a task to the executor for asynchronous processing.
   #
@@ -25,13 +25,13 @@ module Concurrent
   #
   #   @return [self] returns itself
 
-  # @!macro [new] executor_service_method_can_overflow_question
+  # @!macro executor_service_method_can_overflow_question
   #
   #   Does the task queue have a maximum size?
   #
   #   @return [Boolean] True if the task queue has a maximum size else false.
 
-  # @!macro [new] executor_service_method_serialized_question
+  # @!macro executor_service_method_serialized_question
   #
   #   Does this executor guarantee serialization of its operations?
   #
@@ -41,7 +41,7 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] executor_service_public_api
+  # @!macro executor_service_public_api
   #
   #   @!method post(*args, &task)
   #     @!macro executor_service_method_post
@@ -57,23 +57,23 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] executor_service_attr_reader_fallback_policy
+  # @!macro executor_service_attr_reader_fallback_policy
   #   @return [Symbol] The fallback policy in effect. Either `:abort`, `:discard`, or `:caller_runs`.
 
-  # @!macro [new] executor_service_method_shutdown
+  # @!macro executor_service_method_shutdown
   #
   #   Begin an orderly shutdown. Tasks already in the queue will be executed,
   #   but no new tasks will be accepted. Has no additional effect if the
   #   thread pool is not running.
 
-  # @!macro [new] executor_service_method_kill
+  # @!macro executor_service_method_kill
   #
   #   Begin an immediate shutdown. In-progress tasks will be allowed to
   #   complete but enqueued tasks will be dismissed and no new tasks
   #   will be accepted. Has no additional effect if the thread pool is
   #   not running.
 
-  # @!macro [new] executor_service_method_wait_for_termination
+  # @!macro executor_service_method_wait_for_termination
   #
   #   Block until executor shutdown is complete or until `timeout` seconds have
   #   passed.
@@ -85,31 +85,31 @@ module Concurrent
   #
   #   @return [Boolean] `true` if shutdown complete or false on `timeout`
 
-  # @!macro [new] executor_service_method_running_question
+  # @!macro executor_service_method_running_question
   #
   #   Is the executor running?
   #
   #   @return [Boolean] `true` when running, `false` when shutting down or shutdown
 
-  # @!macro [new] executor_service_method_shuttingdown_question
+  # @!macro executor_service_method_shuttingdown_question
   #
   #   Is the executor shuttingdown?
   #
   #   @return [Boolean] `true` when not running and not shutdown, else `false`
 
-  # @!macro [new] executor_service_method_shutdown_question
+  # @!macro executor_service_method_shutdown_question
   #
   #   Is the executor shutdown?
   #
   #   @return [Boolean] `true` when shutdown, `false` when shutting down or running
 
-  # @!macro [new] executor_service_method_auto_terminate_question
+  # @!macro executor_service_method_auto_terminate_question
   #
   #   Is the executor auto-terminate when the application exits?
   #
   #   @return [Boolean] `true` when auto-termination is enabled else `false`.
 
-  # @!macro [new] executor_service_method_auto_terminate_setter
+  # @!macro executor_service_method_auto_terminate_setter
   #
   #   Set the auto-terminate behavior for this executor.
   #
@@ -119,7 +119,7 @@ module Concurrent
 
   ###################################################################
 
-  # @!macro [new] abstract_executor_service_public_api
+  # @!macro abstract_executor_service_public_api
   #
   #   @!macro executor_service_public_api
   #

data/lib/concurrent/executor/fixed_thread_pool.rb

@@ -3,44 +3,44 @@ require 'concurrent/executor/thread_pool_executor'
 
 module Concurrent
 
-  # @!macro [new] thread_pool_executor_constant_default_max_pool_size
+  # @!macro thread_pool_executor_constant_default_max_pool_size
   #   Default maximum number of threads that will be created in the pool.
 
-  # @!macro [new] thread_pool_executor_constant_default_min_pool_size
+  # @!macro thread_pool_executor_constant_default_min_pool_size
   #   Default minimum number of threads that will be retained in the pool.
 
-  # @!macro [new] thread_pool_executor_constant_default_max_queue_size
+  # @!macro thread_pool_executor_constant_default_max_queue_size
   #   Default maximum number of tasks that may be added to the task queue.
 
-  # @!macro [new] thread_pool_executor_constant_default_thread_timeout
+  # @!macro thread_pool_executor_constant_default_thread_timeout
   #   Default maximum number of seconds a thread in the pool may remain idle
   #   before being reclaimed.
 
-  # @!macro [new] thread_pool_executor_attr_reader_max_length
+  # @!macro thread_pool_executor_attr_reader_max_length
   #   The maximum number of threads that may be created in the pool.
   #   @return [Integer] The maximum number of threads that may be created in the pool.
 
-  # @!macro [new] thread_pool_executor_attr_reader_min_length
+  # @!macro thread_pool_executor_attr_reader_min_length
   #   The minimum number of threads that may be retained in the pool.
   #   @return [Integer] The minimum number of threads that may be retained in the pool.
 
-  # @!macro [new] thread_pool_executor_attr_reader_largest_length
+  # @!macro thread_pool_executor_attr_reader_largest_length
   #   The largest number of threads that have been created in the pool since construction.
   #   @return [Integer] The largest number of threads that have been created in the pool since construction.
 
-  # @!macro [new] thread_pool_executor_attr_reader_scheduled_task_count
+  # @!macro thread_pool_executor_attr_reader_scheduled_task_count
   #   The number of tasks that have been scheduled for execution on the pool since construction.
   #   @return [Integer] The number of tasks that have been scheduled for execution on the pool since construction.
 
-  # @!macro [new] thread_pool_executor_attr_reader_completed_task_count
+  # @!macro thread_pool_executor_attr_reader_completed_task_count
   #   The number of tasks that have been completed by the pool since construction.
   #   @return [Integer] The number of tasks that have been completed by the pool since construction.
 
-  # @!macro [new] thread_pool_executor_attr_reader_idletime
+  # @!macro thread_pool_executor_attr_reader_idletime
   #   The number of seconds that a thread may be idle before being reclaimed.
   #   @return [Integer] The number of seconds that a thread may be idle before being reclaimed.
 
-  # @!macro [new] thread_pool_executor_attr_reader_max_queue
+  # @!macro thread_pool_executor_attr_reader_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 `fallback_policy`.
@@ -49,15 +49,15 @@ module Concurrent
   #     When the queue size reaches `max_queue` subsequent tasks will be rejected in
   #     accordance with the configured `fallback_policy`.
 
-  # @!macro [new] thread_pool_executor_attr_reader_length
+  # @!macro thread_pool_executor_attr_reader_length
   #   The number of threads currently in the pool.
   #   @return [Integer] The number of threads currently in the pool.
 
-  # @!macro [new] thread_pool_executor_attr_reader_queue_length
+  # @!macro thread_pool_executor_attr_reader_queue_length
   #   The number of tasks in the queue awaiting execution.
   #   @return [Integer] The number of tasks in the queue awaiting execution.
 
-  # @!macro [new] thread_pool_executor_attr_reader_remaining_capacity
+  # @!macro thread_pool_executor_attr_reader_remaining_capacity
   #   Number of tasks that may be enqueued before reaching `max_queue` and rejecting
   #   new tasks. A value of -1 indicates that the queue may grow without bound.
   #
@@ -68,7 +68,7 @@ module Concurrent
 
 
 
-  # @!macro [new] thread_pool_executor_public_api
+  # @!macro thread_pool_executor_public_api
   #
   #   @!macro abstract_executor_service_public_api
   #
@@ -108,7 +108,7 @@ module Concurrent
 
 
 
-  # @!macro [new] thread_pool_options
+  # @!macro thread_pool_options
   #
   #   **Thread Pool Options**
   #
@@ -169,7 +169,7 @@ module Concurrent
 
 
 
-  # @!macro [attach] fixed_thread_pool
+  # @!macro fixed_thread_pool
   #
   #   A thread pool that reuses a fixed number of threads operating off an unbounded queue.
   #   At any point, at most `num_threads` will be active processing tasks. When all threads are busy new
@@ -182,7 +182,7 @@ module Concurrent
   # @!macro thread_pool_options
   class FixedThreadPool < ThreadPoolExecutor
 
-    # @!macro [attach] fixed_thread_pool_method_initialize
+    # @!macro fixed_thread_pool_method_initialize
     #
     #   Create a new thread pool.
     #