concurrent-ruby 1.0.5 → 1.1.6

data/lib/{concurrent → concurrent-ruby/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.
     #
@@ -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

@@ -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,41 +85,41 @@ 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.
   #
+  #   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`.
 
   ###################################################################
 
-  # @!macro [new] abstract_executor_service_public_api
+  # @!macro abstract_executor_service_public_api
   #
   #   @!macro executor_service_public_api
   #

data/lib/{concurrent → concurrent-ruby/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,19 +108,20 @@ module Concurrent
 
 
 
-  # @!macro [new] thread_pool_options
+  # @!macro thread_pool_options
   #
   #   **Thread Pool Options**
   #
   #   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 +146,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,13 +160,13 @@ 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-
 
 
 
 
 
-  # @!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 +179,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 → concurrent-ruby/concurrent}/executor/java_executor_service.rb

@@ -18,15 +18,10 @@ if Concurrent.on_jruby?
       }.freeze
       private_constant :FALLBACK_POLICY_CLASSES
 
-      def initialize(*args, &block)
-        super
-        ns_make_executor_runnable
-      end
-
       def post(*args, &task)
         raise ArgumentError.new('no block given') unless block_given?
         return handle_fallback(*args, &task) unless running?
-        @executor.submit_runnable Job.new(args, task)
+        @executor.submit Job.new(args, task)
         true
       rescue Java::JavaUtilConcurrent::RejectedExecutionException
         raise RejectedExecutionError
@@ -43,7 +38,6 @@ if Concurrent.on_jruby?
 
       def shutdown
         synchronize do
-          self.ns_auto_terminate = false
           @executor.shutdown
           nil
         end
@@ -51,7 +45,6 @@ if Concurrent.on_jruby?
 
       def kill
         synchronize do
-          self.ns_auto_terminate = false
           @executor.shutdownNow
           nil
         end
@@ -75,14 +68,6 @@ if Concurrent.on_jruby?
         @executor.isShutdown || @executor.isTerminated
       end
 
-      def ns_make_executor_runnable
-        if !defined?(@executor.submit_runnable)
-          @executor.class.class_eval do
-            java_alias :submit_runnable, :submit, [java.lang.Runnable.java_class]
-          end
-        end
-      end
-
       class Job
         include Runnable
         def initialize(args, block)
@@ -96,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

@@ -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,12 +109,16 @@ 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,
+            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

@@ -27,7 +27,6 @@ module Concurrent
     def shutdown
       synchronize do
         break unless running?
-        self.ns_auto_terminate = false
         stop_event.set
         ns_shutdown_execution
       end
@@ -37,7 +36,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