concurrent-ruby 1.1.5 → 1.2.2

data/lib/concurrent-ruby/concurrent/configuration.rb

@@ -0,0 +1,105 @@
+require 'thread'
+require 'concurrent/delay'
+require 'concurrent/errors'
+require 'concurrent/concern/deprecation'
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/fixed_thread_pool'
+require 'concurrent/executor/cached_thread_pool'
+require 'concurrent/utility/processor_counter'
+
+module Concurrent
+  extend Concern::Deprecation
+
+  autoload :Options, 'concurrent/options'
+  autoload :TimerSet, 'concurrent/executor/timer_set'
+  autoload :ThreadPoolExecutor, 'concurrent/executor/thread_pool_executor'
+
+  # @!visibility private
+  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 }
+  private_constant :GLOBAL_IO_EXECUTOR
+
+  # @!visibility private
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new }
+  private_constant :GLOBAL_TIMER_SET
+
+  # @!visibility private
+  GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
+  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
+
+  # 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.
+  #
+  # @note this option should be needed only because of `at_exit` ordering
+  #   issues which may arise when running some of the testing frameworks.
+  #   E.g. Minitest's test-suite runs itself in `at_exit` callback which
+  #   executes after the pools are already terminated. Then auto termination
+  #   needs to be disabled and called manually after test-suite ends.
+  # @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.
+  # @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!
+    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*.
+  #
+  # @return [ThreadPoolExecutor] the thread pool
+  def self.global_fast_executor
+    GLOBAL_FAST_EXECUTOR.value!
+  end
+
+  # Global thread pool optimized for long, blocking (IO) *tasks*.
+  #
+  # @return [ThreadPoolExecutor] the thread pool
+  def self.global_io_executor
+    GLOBAL_IO_EXECUTOR.value!
+  end
+
+  def self.global_immediate_executor
+    GLOBAL_IMMEDIATE_EXECUTOR
+  end
+
+  # Global thread pool user for global *timers*.
+  #
+  # @return [Concurrent::TimerSet] the thread pool
+  def self.global_timer_set
+    GLOBAL_TIMER_SET.value!
+  end
+
+  # General access point to global executors.
+  # @param [Symbol, Executor] executor_identifier symbols:
+  #   - :fast - {Concurrent.global_fast_executor}
+  #   - :io - {Concurrent.global_io_executor}
+  #   - :immediate - {Concurrent.global_immediate_executor}
+  # @return [Executor]
+  def self.executor(executor_identifier)
+    Options.executor(executor_identifier)
+  end
+
+  def self.new_fast_executor(opts = {})
+    FixedThreadPool.new(
+        [2, Concurrent.processor_count].max,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "fast"
+    )
+  end
+
+  def self.new_io_executor(opts = {})
+    CachedThreadPool.new(
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "io"
+    )
+  end
+end

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

@@ -1,7 +1,7 @@
 require 'thread'
 require 'concurrent/concern/obligation'
 require 'concurrent/executor/immediate_executor'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
@@ -67,7 +67,7 @@ module Concurrent
 
     # Return the value this object represents after applying the options
     # specified by the `#set_deref_options` method. If the delayed operation
-    # raised an exception this method will return nil. The execption object
+    # raised an exception this method will return nil. The exception object
     # can be accessed via the `#reason` method.
     #
     # @param [Numeric] timeout the maximum number of seconds to wait

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

@@ -66,4 +66,9 @@ module Concurrent
     end
   end
 
+  # @!macro internal_implementation_note
+  class ConcurrentUpdateError < ThreadError
+    # frozen pre-allocated backtrace to speed ConcurrentUpdateError
+    CONC_UP_ERR_BACKTRACE = ['backtrace elided; set verbose to enable'].freeze
+  end
 end

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

@@ -289,6 +289,7 @@ module Concurrent
   end
 
   if Concurrent.on_jruby?
+    require 'concurrent/utility/native_extension_loader'
 
     # @!macro internal_implementation_note
     # @!visibility private

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/abstract_executor_service.rb

@@ -1,7 +1,7 @@
 require 'concurrent/errors'
+require 'concurrent/concern/deprecation'
 require 'concurrent/executor/executor_service'
-require 'concurrent/synchronization'
-require 'concurrent/utility/at_exit'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
@@ -9,6 +9,7 @@ module Concurrent
   # @!visibility private
   class AbstractExecutorService < Synchronization::LockableObject
     include ExecutorService
+    include Concern::Deprecation
 
     # The set of possible fallback policies that may be set at thread pool creation.
     FALLBACK_POLICIES = [:abort, :discard, :caller_runs].freeze
@@ -16,10 +17,20 @@ module Concurrent
     # @!macro executor_service_attr_reader_fallback_policy
     attr_reader :fallback_policy
 
+    attr_reader :name
+
     # Create a new thread pool.
-    def initialize(*args, &block)
+    def initialize(opts = {}, &block)
       super(&nil)
-      synchronize { ns_initialize(*args, &block) }
+      synchronize do
+        @auto_terminate = opts.fetch(:auto_terminate, true)
+        @name = opts.fetch(:name) if opts.key?(:name)
+        ns_initialize(opts, &block)
+      end
+    end
+
+    def to_s
+      name ? "#{super[0..-2]} name: #{name}>" : super
     end
 
     # @!macro executor_service_method_shutdown
@@ -54,38 +65,41 @@ module Concurrent
 
     # @!macro executor_service_method_auto_terminate_question
     def auto_terminate?
-      synchronize { ns_auto_terminate? }
+      synchronize { @auto_terminate }
     end
 
     # @!macro executor_service_method_auto_terminate_setter
     def auto_terminate=(value)
-      synchronize { self.ns_auto_terminate = value }
+      deprecated "Method #auto_terminate= has no effect. Set :auto_terminate option when executor is initialized."
     end
 
     private
 
-    # Handler which executes the `fallback_policy` once the queue size
-    # reaches `max_queue`.
+    # Returns an action which executes the `fallback_policy` once the queue
+    # size reaches `max_queue`. The reason for the indirection of an action
+    # is so that the work can be deferred outside of synchronization.
     #
     # @param [Array] args the arguments to the task which is being handled.
     #
     # @!visibility private
-    def handle_fallback(*args)
+    def fallback_action(*args)
       case fallback_policy
       when :abort
-        raise RejectedExecutionError
+        lambda { raise RejectedExecutionError }
       when :discard
-        false
+        lambda { false }
       when :caller_runs
-        begin
-          yield(*args)
-        rescue => ex
-          # let it fail
-          log DEBUG, ex
-        end
-        true
+        lambda {
+          begin
+            yield(*args)
+          rescue => ex
+            # let it fail
+            log DEBUG, ex
+          end
+          true
+        }
       else
-        fail "Unknown fallback policy #{fallback_policy}"
+        lambda { fail "Unknown fallback policy #{fallback_policy}" }
       end
     end
 
@@ -110,25 +124,8 @@ module Concurrent
     end
 
     def ns_auto_terminate?
-      !!@auto_terminate
+      @auto_terminate
     end
 
-    def ns_auto_terminate=(value)
-      case value
-      when true
-        AtExit.add(self) { terminate_at_exit }
-        @auto_terminate = true
-      when false
-        AtExit.delete(self)
-        @auto_terminate = false
-      else
-        raise ArgumentError
-      end
-    end
-
-    def terminate_at_exit
-      kill # TODO be gentle first
-      wait_for_termination(10)
-    end
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/cached_thread_pool.rb

@@ -37,7 +37,7 @@ module Concurrent
     #
     #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
     def initialize(opts = {})
-      defaults  = { idletime:    DEFAULT_THREAD_IDLETIMEOUT }
+      defaults  = { idletime: DEFAULT_THREAD_IDLETIMEOUT }
       overrides = { min_threads: 0,
                     max_threads: DEFAULT_MAX_POOL_SIZE,
                     max_queue:   DEFAULT_MAX_QUEUE_SIZE }
@@ -51,11 +51,11 @@ module Concurrent
     def ns_initialize(opts)
       super(opts)
       if Concurrent.on_jruby?
-        @max_queue = 0
-        @executor = java.util.concurrent.Executors.newCachedThreadPool
+        @max_queue          = 0
+        @executor           = java.util.concurrent.Executors.newCachedThreadPool(
+            DaemonThreadFactory.new(ns_auto_terminate?))
         @executor.setRejectedExecutionHandler(FALLBACK_POLICY_CLASSES[@fallback_policy].new)
         @executor.setKeepAliveTime(opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT), java.util.concurrent.TimeUnit::SECONDS)
-        self.auto_terminate = opts.fetch(:auto_terminate, true)
       end
     end
   end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/executor_service.rb

@@ -111,10 +111,10 @@ module Concurrent
 
   # @!macro executor_service_method_auto_terminate_setter
   #
-  #   Set the auto-terminate behavior for this executor.
   #
+  #   Set the auto-terminate behavior for this executor.
+  #   @deprecated Has no effect
   #   @param [Boolean] value The new auto-terminate value to set for this executor.
-  #
   #   @return [Boolean] `true` when auto-termination is enabled else `false`.
 
   ###################################################################

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/fixed_thread_pool.rb

@@ -16,6 +16,9 @@ module Concurrent
   #   Default maximum number of seconds a thread in the pool may remain idle
   #   before being reclaimed.
 
+  # @!macro thread_pool_executor_constant_default_synchronous
+  #   Default value of the :synchronous option.
+
   # @!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.
@@ -40,6 +43,10 @@ module Concurrent
   #   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 thread_pool_executor_attr_reader_synchronous
+  #   Whether or not a value of 0 for :max_queue option means the queue must perform direct hand-off or rather unbounded queue.
+  #   @return [true, false]
+
   # @!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
@@ -64,9 +71,16 @@ module Concurrent
   #   @return [Integer] 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.
 
-
-
-
+  # @!macro thread_pool_executor_method_prune_pool
+  #   Prune the thread pool of unneeded threads
+  #
+  #   What is being pruned is controlled by the min_threads and idletime
+  #   parameters passed at pool creation time
+  #
+  #   This is a no-op on some pool implementation (e.g. the Java one).  The Ruby
+  #   pool will auto-prune each time a new job is posted. You will need to call
+  #   this method explicitely in case your application post jobs in bursts (a
+  #   lot of jobs and then nothing for long periods)
 
   # @!macro thread_pool_executor_public_api
   #
@@ -104,6 +118,9 @@ module Concurrent
   #
   #   @!method can_overflow?
   #     @!macro executor_service_method_can_overflow_question
+  #
+  #   @!method prune_pool
+  #     @!macro thread_pool_executor_method_prune_pool
 
 
 
@@ -115,12 +132,13 @@ module Concurrent
   #   Thread pools support several configuration options:
   #
   #   * `idletime`: The number of seconds that a thread may be idle before being reclaimed.
+  #   * `name`: The name of the executor (optional). Printed in the executor's `#to_s` output and
+  #     a `<name>-worker-<id>` name is given to its threads if supported by used Ruby
+  #     implementation. `<id>` is uniq for each thread.
   #   * `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` and no new threads can be created,
   #     subsequent tasks will be rejected in accordance with the configured `fallback_policy`.
-  #   * `auto_terminate`: When true (default) an `at_exit` handler will be registered which
-  #     will stop the thread pool when the application exits. See below for more information
-  #     on shutting down thread pools.
+  #   * `auto_terminate`: When true (default), the threads started will be marked as daemon.
   #   * `fallback_policy`: The policy defining how rejected tasks are handled.
   #
   #   Three fallback policies are supported:
@@ -145,16 +163,12 @@ module Concurrent
   #
   #   On some runtime platforms (most notably the JVM) the application will not
   #   exit until all thread pools have been shutdown. To prevent applications from
-  #   "hanging" on exit all thread pools include an `at_exit` handler that will
-  #   stop the thread pool when the application exits. This handler uses a brute
-  #   force method to stop the pool and makes no guarantees regarding resources being
-  #   used by any tasks still running. Registration of this `at_exit` handler can be
-  #   prevented by setting the thread pool's constructor `:auto_terminate` option to
-  #   `false` when the thread pool is created. All thread pools support this option.
+  #   "hanging" on exit, all threads can be marked as daemon according to the
+  #   `:auto_terminate` option.
   #
   #   ```ruby
-  #   pool1 = Concurrent::FixedThreadPool.new(5) # an `at_exit` handler will be registered
-  #   pool2 = Concurrent::FixedThreadPool.new(5, auto_terminate: false) # prevent `at_exit` handler registration
+  #   pool1 = Concurrent::FixedThreadPool.new(5) # threads will be marked as daemon
+  #   pool2 = Concurrent::FixedThreadPool.new(5, auto_terminate: false) # mark threads as non-daemon
   #   ```
   #
   #   @note Failure to properly shutdown a thread pool can lead to unpredictable results.
@@ -163,7 +177,7 @@ module Concurrent
   #   @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html Java Tutorials: Thread Pools
   #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html Java Executors class
   #   @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html Java ExecutorService interface
-  #   @see http://ruby-doc.org//core-2.2.0/Kernel.html#method-i-at_exit Kernel#at_exit
+  #   @see https://docs.oracle.com/javase/8/docs/api/java/lang/Thread.html#setDaemon-boolean-
 
 
 

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/java_executor_service.rb

@@ -1,7 +1,7 @@
-if Concurrent.on_jruby?
+require 'concurrent/utility/engine'
 
+if Concurrent.on_jruby?
   require 'concurrent/errors'
-  require 'concurrent/utility/engine'
   require 'concurrent/executor/abstract_executor_service'
 
   module Concurrent
@@ -18,13 +18,9 @@ if Concurrent.on_jruby?
       }.freeze
       private_constant :FALLBACK_POLICY_CLASSES
 
-      def initialize(*args, &block)
-        super
-      end
-
       def post(*args, &task)
         raise ArgumentError.new('no block given') unless block_given?
-        return handle_fallback(*args, &task) unless running?
+        return fallback_action(*args, &task).call unless running?
         @executor.submit Job.new(args, task)
         true
       rescue Java::JavaUtilConcurrent::RejectedExecutionException
@@ -42,7 +38,6 @@ if Concurrent.on_jruby?
 
       def shutdown
         synchronize do
-          self.ns_auto_terminate = false
           @executor.shutdown
           nil
         end
@@ -50,7 +45,6 @@ if Concurrent.on_jruby?
 
       def kill
         synchronize do
-          self.ns_auto_terminate = false
           @executor.shutdownNow
           nil
         end
@@ -87,5 +81,23 @@ if Concurrent.on_jruby?
       end
       private_constant :Job
     end
+
+    class DaemonThreadFactory
+      # hide include from YARD
+      send :include, java.util.concurrent.ThreadFactory
+
+      def initialize(daemonize = true)
+        @daemonize = daemonize
+      end
+
+      def newThread(runnable)
+        thread = java.util.concurrent.Executors.defaultThreadFactory().newThread(runnable)
+        thread.setDaemon(@daemonize)
+        return thread
+      end
+    end
+
+    private_constant :DaemonThreadFactory
+
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/java_single_thread_executor.rb

@@ -17,12 +17,13 @@ if Concurrent.on_jruby?
       end
 
       private
-      
+
       def ns_initialize(opts)
-        @executor = java.util.concurrent.Executors.newSingleThreadExecutor
+        @executor = java.util.concurrent.Executors.newSingleThreadExecutor(
+            DaemonThreadFactory.new(ns_auto_terminate?)
+        )
         @fallback_policy = opts.fetch(:fallback_policy, :discard)
         raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICY_CLASSES.keys.include?(@fallback_policy)
-        self.auto_terminate = opts.fetch(:auto_terminate, true)
       end
     end
   end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/java_thread_pool_executor.rb

@@ -21,12 +21,18 @@ if Concurrent.on_jruby?
       # @!macro thread_pool_executor_constant_default_thread_timeout
       DEFAULT_THREAD_IDLETIMEOUT = 60
 
+      # @!macro thread_pool_executor_constant_default_synchronous
+      DEFAULT_SYNCHRONOUS = false
+
       # @!macro thread_pool_executor_attr_reader_max_length
       attr_reader :max_length
 
       # @!macro thread_pool_executor_attr_reader_max_queue
       attr_reader :max_queue
 
+      # @!macro thread_pool_executor_attr_reader_synchronous
+      attr_reader :synchronous
+
       # @!macro thread_pool_executor_method_initialize
       def initialize(opts = {})
         super(opts)
@@ -87,6 +93,10 @@ if Concurrent.on_jruby?
         super && !@executor.isTerminating
       end
 
+      # @!macro thread_pool_executor_method_prune_pool
+      def prune_pool
+      end
+
       private
 
       def ns_initialize(opts)
@@ -94,8 +104,10 @@ if Concurrent.on_jruby?
         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
+        @synchronous     = opts.fetch(:synchronous, DEFAULT_SYNCHRONOUS)
         @fallback_policy = opts.fetch(:fallback_policy, :abort)
 
+        raise ArgumentError.new("`synchronous` cannot be set unless `max_queue` is 0") if @synchronous && @max_queue > 0
         raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if max_length < DEFAULT_MIN_POOL_SIZE
         raise ArgumentError.new("`max_threads` cannot be greater than #{DEFAULT_MAX_POOL_SIZE}") if max_length > DEFAULT_MAX_POOL_SIZE
         raise ArgumentError.new("`min_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if min_length < DEFAULT_MIN_POOL_SIZE
@@ -103,7 +115,11 @@ if Concurrent.on_jruby?
         raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICY_CLASSES.include?(@fallback_policy)
 
         if @max_queue == 0
-          queue = java.util.concurrent.LinkedBlockingQueue.new
+          if @synchronous
+            queue = java.util.concurrent.SynchronousQueue.new
+          else
+            queue = java.util.concurrent.LinkedBlockingQueue.new
+          end
         else
           queue = java.util.concurrent.LinkedBlockingQueue.new(@max_queue)
         end
@@ -114,10 +130,11 @@ if Concurrent.on_jruby?
             idletime,
             java.util.concurrent.TimeUnit::SECONDS,
             queue,
+            DaemonThreadFactory.new(ns_auto_terminate?),
             FALLBACK_POLICY_CLASSES[@fallback_policy].new)
 
-        self.auto_terminate = opts.fetch(:auto_terminate, true)
       end
     end
+
   end
 end

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/ruby_executor_service.rb

@@ -16,10 +16,16 @@ module Concurrent
 
     def post(*args, &task)
       raise ArgumentError.new('no block given') unless block_given?
-      synchronize do
-        # If the executor is shut down, reject this task
-        return handle_fallback(*args, &task) unless running?
-        ns_execute(*args, &task)
+      deferred_action = synchronize {
+        if running?
+          ns_execute(*args, &task)
+        else
+          fallback_action(*args, &task)
+        end
+      }
+      if deferred_action
+        deferred_action.call
+      else
         true
       end
     end
@@ -27,7 +33,6 @@ module Concurrent
     def shutdown
       synchronize do
         break unless running?
-        self.ns_auto_terminate = false
         stop_event.set
         ns_shutdown_execution
       end
@@ -37,7 +42,6 @@ module Concurrent
     def kill
       synchronize do
         break if shutdown?
-        self.ns_auto_terminate = false
         stop_event.set
         ns_kill_execution
         stopped_event.set

data/lib/{concurrent → concurrent-ruby/concurrent}/executor/ruby_single_thread_executor.rb

@@ -15,7 +15,6 @@ module Concurrent
         max_queue: 0,
         idletime: DEFAULT_THREAD_IDLETIMEOUT,
         fallback_policy: opts.fetch(:fallback_policy, :discard),
-        auto_terminate: opts.fetch(:auto_terminate, true)
       )
     end
   end