concurrent-ruby 1.0.5 → 1.1.1

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.
     #

data/lib/concurrent/executor/java_thread_pool_executor.rb

@@ -90,10 +90,10 @@ if Concurrent.on_jruby?
       private
 
       def ns_initialize(opts)
-        min_length = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
-        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
+        min_length       = opts.fetch(:min_threads, DEFAULT_MIN_POOL_SIZE).to_i
+        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
         @fallback_policy = opts.fetch(:fallback_policy, :abort)
 
         raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if max_length < DEFAULT_MIN_POOL_SIZE
@@ -109,9 +109,12 @@ if Concurrent.on_jruby?
         end
 
         @executor = java.util.concurrent.ThreadPoolExecutor.new(
-          min_length, max_length,
-          idletime, java.util.concurrent.TimeUnit::SECONDS,
-          queue, FALLBACK_POLICY_CLASSES[@fallback_policy].new)
+            min_length,
+            max_length,
+            idletime,
+            java.util.concurrent.TimeUnit::SECONDS,
+            queue,
+            FALLBACK_POLICY_CLASSES[@fallback_policy].new)
 
         self.auto_terminate = opts.fetch(:auto_terminate, true)
       end

data/lib/concurrent/executor/single_thread_executor.rb

@@ -14,7 +14,7 @@ module Concurrent
                                        end
   private_constant :SingleThreadExecutorImplementation
 
-  # @!macro [attach] single_thread_executor
+  # @!macro single_thread_executor
   #
   #   A thread pool with a single thread an unlimited queue. Should the thread
   #   die for any reason it will be removed and replaced, thus ensuring that
@@ -35,7 +35,7 @@ module Concurrent
   # @!macro abstract_executor_service_public_api
   class SingleThreadExecutor < SingleThreadExecutorImplementation
 
-    # @!macro [new] single_thread_executor_method_initialize
+    # @!macro single_thread_executor_method_initialize
     #
     #   Create a new thread pool.
     #

data/lib/concurrent/executor/thread_pool_executor.rb

@@ -15,7 +15,7 @@ module Concurrent
                                      end
   private_constant :ThreadPoolExecutorImplementation
 
-  # @!macro [attach] thread_pool_executor
+  # @!macro thread_pool_executor
   #
   #   An abstraction composed of one or more threads and a task queue. Tasks
   #   (blocks or `proc` objects) are submitted to the pool and added to the queue.
@@ -55,12 +55,12 @@ module Concurrent
   # @!macro thread_pool_executor_public_api
   class ThreadPoolExecutor < ThreadPoolExecutorImplementation
 
-    # @!macro [new] thread_pool_executor_method_initialize
+    # @!macro thread_pool_executor_method_initialize
     #
     #   Create a new thread pool.
-    #  
+    #
     #   @param [Hash] opts the options which configure the thread pool.
-    #  
+    #
     #   @option opts [Integer] :max_threads (DEFAULT_MAX_POOL_SIZE) the maximum
     #     number of threads to be created
     #   @option opts [Integer] :min_threads (DEFAULT_MIN_POOL_SIZE) When a new task is submitted
@@ -73,12 +73,12 @@ module Concurrent
     #   @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 `: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
 
     # @!method initialize(opts = {})

data/lib/concurrent/executor/timer_set.rb

@@ -20,7 +20,7 @@ module Concurrent
 
     # Create a new set of timed tasks.
     #
-    # @!macro [attach] executor_options
+    # @!macro executor_options
     #
     #   @param [Hash] opts the options used to specify the executor on which to perform actions
     #   @option opts [Executor] :executor when set use the given `Executor` instance.

data/lib/concurrent/future.rb

@@ -6,9 +6,12 @@ require 'concurrent/executor/safe_task_executor'
 
 require 'concurrent/options'
 
+# TODO (pitr-ch 14-Mar-2017): deprecate, Future, Promise, etc.
+
+
 module Concurrent
 
-  # {include:file:doc/future.md}
+  # {include:file:docs-source/future.md}
   #
   # @!macro copy_options
   #

data/lib/concurrent/hash.rb

@@ -2,35 +2,58 @@ require 'concurrent/utility/engine'
 require 'concurrent/thread_safe/util'
 
 module Concurrent
-  if Concurrent.on_cruby?
-
-    # @!macro [attach] concurrent_hash
-    #
-    #   A thread-safe subclass of Hash. This version locks against the object
-    #   itself for every method call, ensuring only one thread can be reading
-    #   or writing at a time. This includes iteration methods like `#each`,
-    #   which takes the lock repeatedly when reading an item.
-    #
-    #   @see http://ruby-doc.org/core-2.2.0/Hash.html Ruby standard library `Hash`
-    class Hash < ::Hash;
-    end
-
-  elsif Concurrent.on_jruby?
-    require 'jruby/synchronized'
-
-    # @!macro concurrent_hash
-    class Hash < ::Hash
-      include JRuby::Synchronized
-    end
-
-  elsif Concurrent.on_rbx? || Concurrent.on_truffle?
-    require 'monitor'
-    require 'concurrent/thread_safe/util/array_hash_rbx'
-
-    # @!macro concurrent_hash
-    class Hash < ::Hash
-    end
-
-    ThreadSafe::Util.make_synchronized_on_rbx Hash
+
+  # @!macro concurrent_hash
+  #
+  #   A thread-safe subclass of Hash. This version locks against the object
+  #   itself for every method call, ensuring only one thread can be reading
+  #   or writing at a time. This includes iteration methods like `#each`,
+  #   which takes the lock repeatedly when reading an item.
+  #
+  #   @see http://ruby-doc.org/core-2.2.0/Hash.html Ruby standard library `Hash`
+
+  # @!macro internal_implementation_note
+  HashImplementation = case
+                       when Concurrent.on_cruby?
+                         # Because MRI never runs code in parallel, the existing
+                         # non-thread-safe structures should usually work fine.
+                         ::Hash
+
+                       when Concurrent.on_jruby?
+                         require 'jruby/synchronized'
+
+                         class JRubyHash < ::Hash
+                           include JRuby::Synchronized
+                         end
+                         JRubyHash
+
+                       when Concurrent.on_rbx?
+                         require 'monitor'
+                         require 'concurrent/thread_safe/util/data_structures'
+
+                         class RbxHash < ::Hash
+                         end
+                         ThreadSafe::Util.make_synchronized_on_rbx RbxHash
+                         RbxHash
+
+                       when Concurrent.on_truffleruby?
+                         require 'concurrent/thread_safe/util/data_structures'
+
+                         class TruffleRubyHash < ::Hash
+                         end
+
+                         ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubyHash
+                         TruffleRubyHash
+
+                       else
+                         warn 'Possibly unsupported Ruby implementation'
+                         ::Hash
+                       end
+  private_constant :HashImplementation
+
+  # @!macro concurrent_hash
+  class Hash < HashImplementation
   end
+
 end
+

data/lib/concurrent/ivar.rb

@@ -98,10 +98,10 @@ module Concurrent
       observer
     end
 
-    # @!macro [attach] ivar_set_method
+    # @!macro ivar_set_method
     #   Set the `IVar` to a value and wake or notify all threads waiting on it.
     #
-    #   @!macro [attach] ivar_set_parameters_and_exceptions
+    #   @!macro ivar_set_parameters_and_exceptions
     #     @param [Object] value the value to store in the `IVar`
     #     @yield A block operation to use for setting the value
     #     @raise [ArgumentError] if both a value and a block are given
@@ -124,7 +124,7 @@ module Concurrent
       self
     end
 
-    # @!macro [attach] ivar_fail_method
+    # @!macro ivar_fail_method
     #   Set the `IVar` to failed due to some error and wake or notify all threads waiting on it.
     #
     #   @param [Object] reason for the failure
@@ -157,9 +157,8 @@ module Concurrent
       self.observers = Collection::CopyOnWriteObserverSet.new
       set_deref_options(opts)
 
-      if value == NULL
-        @state = :pending
-      else
+      @state = :pending
+      if value != NULL
         ns_complete_without_notification(true, value, nil)
       end
     end