Added 'nuclear option' Concurrent.disable_auto_termination_of_all_executors! method.

Author: jdantonio

lib/concurrent/configuration.rb

@@ -10,34 +10,115 @@ module Concurrent
 
   # initialize the global executors
   class << self
+
+    # @!visibility private
     @@auto_terminate_global_executors = Concurrent::AtomicBoolean.new(true)
 
+    # @!visibility private
+    @@auto_terminate_all_executors = Concurrent::AtomicBoolean.new(true)
+
+    # @!visibility private
     @@global_fast_executor = LazyReference.new do
       Concurrent.new_fast_executor(
         stop_on_exit: @@auto_terminate_global_executors.value)
     end
 
+    # @!visibility private
     @@global_io_executor = LazyReference.new do
       Concurrent.new_io_executor(
         stop_on_exit: @@auto_terminate_global_executors.value)
     end
 
+    # @!visibility private
     @@global_timer_set = LazyReference.new do
       Concurrent::TimerSet.new(
         stop_on_exit: @@auto_terminate_global_executors.value)
     end
   end
 
-  # defines if executors should be auto-terminated with `at_exit` callback
+  # 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 executors should be auto-terminated with `at_exit` callback
+  # 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.
+  #
+  # @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
   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
+  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
+  end
+
   # Global thread pool optimized for short, fast *operations*.
   #
   # @return [ThreadPoolExecutor] the thread pool

lib/concurrent/executor/executor.rb

@@ -71,7 +71,7 @@ def enable_at_exit_handler!(opts = {})
         # without this the application may fail to exit
         @auto_terminate = true
         this = self
-        at_exit { this.kill }
+        at_exit { this.kill if Concurrent.auto_terminate_all_executors? }
       end
     end
   end