Replace at_exit hooks with a register

Author: pitr-ch

.travis.yml

@@ -7,7 +7,7 @@ rvm:
   - 2.0.0
   - 1.9.3
   - ruby-head
-  - jruby-1.7.18
+  - jruby-1.7.19
   - jruby-head
   - rbx-2
 

examples/benchmark_pool.rb

@@ -151,7 +151,7 @@ def initialize(opts = {})
       raise ArgumentError.new('min_threads cannot be more than max_threads') if min_length > max_length
 
       init_executor
-      enable_at_exit_handler!(opts)
+      self.auto_terminate = opts.fetch(:auto_terminate, true)
 
       @pool                 = []
       @queue                = Queue.new

lib/concurrent/configuration.rb

@@ -16,35 +16,20 @@ module Concurrent
   private_constant :GLOBAL_LOGGER
 
   # @!visibility private
-  AUTO_TERMINATE_GLOBAL_EXECUTORS = AtomicBoolean.new(true)
-  private_constant :AUTO_TERMINATE_GLOBAL_EXECUTORS
-
-  # @!visibility private
-  AUTO_TERMINATE_ALL_EXECUTORS = AtomicBoolean.new(true)
-  private_constant :AUTO_TERMINATE_ALL_EXECUTORS
-
-  # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new do
-    Concurrent.new_fast_executor(
-      stop_on_exit: AUTO_TERMINATE_GLOBAL_EXECUTORS.value)
-  end
+  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
   private_constant :GLOBAL_FAST_EXECUTOR
 
   # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new do
-    Concurrent.new_io_executor(
-      stop_on_exit: AUTO_TERMINATE_GLOBAL_EXECUTORS.value)
-  end
+  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
   private_constant :GLOBAL_IO_EXECUTOR
 
   # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new do
-    TimerSet.new(stop_on_exit: AUTO_TERMINATE_GLOBAL_EXECUTORS.value)
-  end
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
   private_constant :GLOBAL_TIMER_SET
 
   # @!visibility private
   GLOBAL_IMMEDIATE_EXECUTOR = ImmediateExecutor.new
+  private_constant :GLOBAL_IMMEDIATE_EXECUTOR
 
   def self.global_logger
     GLOBAL_LOGGER.value
@@ -54,87 +39,34 @@ def self.global_logger=(value)
     GLOBAL_LOGGER.value = value
   end
 
-  # Defines if global executors should be auto-terminated with an
-  # `at_exit` callback. When set to `false` it will be the application
-  # programmer's responsibility to ensure that the global thread pools
-  # are shutdown properly prior to application exit.
-  #
-  # @note Only change this option if you know what you are doing!
-  #   When this is set to true (the default) then `at_exit` handlers
-  #   will be registered automatically for the *global* thread pools
-  #   to ensure that they are shutdown when the application ends. When
-  #   changed to false, the `at_exit` handlers will be circumvented
-  #   for all *global* thread pools. 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.
-  #
-  def self.disable_auto_termination_of_global_executors!
-    AUTO_TERMINATE_GLOBAL_EXECUTORS.make_false
-  end
-
-  # Defines if global executors should be auto-terminated with an
-  # `at_exit` callback. When set to `false` it will be the application
-  # programmer's responsibility to ensure that the global thread pools
-  # are shutdown properly prior to application exit.
+  # Disables pool auto-termination which is called on `at_exit` callback.
+  # When disabled it will be the application
+  # programmer's responsibility to ensure that the thread pools
+  # are shutdown properly prior to application exit
+  # by calling {.terminate_pools!} method.
   #
-  # @note Only change this option if you know what you are doing!
-  #   When this is set to true (the default) then `at_exit` handlers
-  #   will be registered automatically for the *global* thread pools
-  #   to ensure that they are shutdown when the application ends. When
-  #   changed to false, the `at_exit` handlers will be circumvented
-  #   for all *global* thread pools. This method should *never* be called
+  # @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.
-  #
-  # @return [Boolean] true when global thread pools will auto-terminate on
-  #   application exit using an `at_exit` handler; false when no auto-termination
-  #   will occur.
-  def self.auto_terminate_global_executors?
-    AUTO_TERMINATE_GLOBAL_EXECUTORS.value
+  def self.disable_executor_auto_termination!
+    Executor::AT_EXIT_AUTO_TERMINATION.enabled = false
   end
 
-  # Defines if *ALL* executors should be auto-terminated with an
-  # `at_exit` callback. When set to `false` it will be the application
-  # programmer's responsibility to ensure that *all* thread pools,
-  # including the global thread pools, are shutdown properly prior to
-  # application exit.
-  #
-  # @note Only change this option if you know what you are doing!
-  #   When this is set to true (the default) then `at_exit` handlers
-  #   will be registered automatically for *all* thread pools to
-  #   ensure that they are shutdown when the application ends. When
-  #   changed to false, the `at_exit` handlers will be circumvented
-  #   for *all* Concurrent Ruby thread pools running within the
-  #   application. Even those created within other gems used by the
-  #   application. 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.
-  def self.disable_auto_termination_of_all_executors!
-    AUTO_TERMINATE_ALL_EXECUTORS.make_false
+  # @return [true,false]
+  # @see .disable_executor_auto_termination!
+  def self.disable_executor_auto_termination?
+    Executor::AT_EXIT_AUTO_TERMINATION.enabled?
   end
 
-  # Defines if *ALL* executors should be auto-terminated with an
-  # `at_exit` callback. When set to `false` it will be the application
-  # programmer's responsibility to ensure that *all* thread pools,
-  # including the global thread pools, are shutdown properly prior to
-  # application exit.
-  #
-  # @note Only change this option if you know what you are doing!
-  #   When this is set to true (the default) then `at_exit` handlers
-  #   will be registered automatically for *all* thread pools to
-  #   ensure that they are shutdown when the application ends. When
-  #   changed to false, the `at_exit` handlers will be circumvented
-  #   for *all* Concurrent Ruby thread pools running within the
-  #   application. Even those created within other gems used by the
-  #   application. 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.
-  #
-  # @return [Boolean] true when *all* thread pools will auto-terminate on
-  #   application exit using an `at_exit` handler; false when no auto-termination
-  #   will occur.
-  def self.auto_terminate_all_executors?
-    AUTO_TERMINATE_ALL_EXECUTORS.value
+  # terminates all pools and blocks until they are terminated
+  # @see .disable_executor_auto_termination!
+  def self.terminate_pools!
+    Executor::AT_EXIT_AUTO_TERMINATION.terminate
   end
 
   # Global thread pool optimized for short, fast *operations*.
@@ -151,6 +83,10 @@ 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
@@ -160,44 +96,25 @@ def self.global_timer_set
     GLOBAL_TIMER_SET.value
   end
 
-  def self.shutdown_global_executors
-    global_fast_executor.shutdown
-    global_io_executor.shutdown
-    global_timer_set.shutdown
-  end
-
-  def self.kill_global_executors
-    global_fast_executor.kill
-    global_io_executor.kill
-    global_timer_set.kill
-  end
-
-  def self.wait_for_global_executors_termination(timeout = nil)
-    latch = CountDownLatch.new(3)
-    [ global_fast_executor, global_io_executor, global_timer_set ].each do |executor|
-      Thread.new{ executor.wait_for_termination(timeout); latch.count_down }
-    end
-    latch.wait(timeout)
-  end
-
   def self.new_fast_executor(opts = {})
     FixedThreadPool.new(
-      [2, Concurrent.processor_count].max,
-      stop_on_exit:    opts.fetch(:stop_on_exit, true),
-      idletime:        60,          # 1 minute
-      max_queue:       0,           # unlimited
-      fallback_policy: :caller_runs # shouldn't matter -- 0 max queue
+        [2, Concurrent.processor_count].max,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :caller_runs # shouldn't matter -- 0 max queue
     )
   end
 
   def self.new_io_executor(opts = {})
     ThreadPoolExecutor.new(
-      min_threads:     [2, Concurrent.processor_count].max,
-      max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
-      stop_on_exit:    opts.fetch(:stop_on_exit, true),
-      idletime:        60,          # 1 minute
-      max_queue:       0,           # unlimited
-      fallback_policy: :caller_runs # shouldn't matter -- 0 max queue
+        min_threads:     [2, Concurrent.processor_count].max,
+        max_threads:     ThreadPoolExecutor::DEFAULT_MAX_POOL_SIZE,
+        # max_threads:     1000,
+        auto_terminate:  opts.fetch(:auto_terminate, true),
+        idletime:        60, # 1 minute
+        max_queue:       0, # unlimited
+        fallback_policy: :caller_runs # shouldn't matter -- 0 max queue
     )
   end
 
@@ -256,15 +173,15 @@ def global_timer_set
     def global_task_pool=(executor)
       warn '[DEPRECATED] Replacing global thread pools is deprecated. Use the :executor constructor option instead.'
       GLOBAL_IO_EXECUTOR.reconfigure { executor } or
-        raise ConfigurationError.new('global task pool was already set')
+          raise ConfigurationError.new('global task pool was already set')
     end
 
     # @deprecated Replacing global thread pools is deprecated.
     #   Use the :executor constructor option instead.
     def global_operation_pool=(executor)
       warn '[DEPRECATED] Replacing global thread pools is deprecated. Use the :executor constructor option instead.'
       GLOBAL_FAST_EXECUTOR.reconfigure { executor } or
-        raise ConfigurationError.new('global operation pool was already set')
+          raise ConfigurationError.new('global operation pool was already set')
     end
 
     # @deprecated Use Concurrent.new_io_executor instead
@@ -293,11 +210,12 @@ def auto_terminate
   end
 
   # create the default configuration on load
-  @configuration = Atomic.new(Configuration.new)
+  CONFIGURATION = Atomic.new(Configuration.new)
+  private_constant :CONFIGURATION
 
   # @return [Configuration]
   def self.configuration
-    @configuration.value
+    CONFIGURATION.value
   end
 
   # Perform gem-level configuration.