Remove AtExit code

Following #840 which allowed all threads created by concurrent-ruby
to be marked as daemon -- specifically in JRuby; the "AtExit" handling
is no longer needed.

Delete all references to "AtExit" and replace it with clearer
documentation that the users can select whether the threads started
shall be marked as daemon threads.

> When a Java Virtual Machine starts up, there is usually a single non-daemon thread (which typically calls the method named main of some designated class).
> The Java Virtual Machine continues to execute threads until either of the following occurs:
>
> 1. The exit method of class Runtime has been called and the security manager has permitted the exit operation to take place.
> 2. All threads that are not daemon threads have died, either by returning from the call to the run method or by throwing an exception that propagates beyond the run method.

Author: fzakaria

lib/concurrent-ruby/concurrent/configuration.rb

@@ -5,7 +5,6 @@
 require 'concurrent/concern/logging'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/cached_thread_pool'
-require 'concurrent/utility/at_exit'
 require 'concurrent/utility/processor_counter'
 
 module Concurrent
@@ -112,24 +111,6 @@ def self.global_logger=(value)
   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.
-  #
-  def self.disable_at_exit_handlers!
-    AT_EXIT.enabled = false
-  end
-
   # Global thread pool optimized for short, fast *operations*.
   #
   # @return [ThreadPoolExecutor] the thread pool

lib/concurrent-ruby/concurrent/executor/abstract_executor_service.rb

@@ -1,7 +1,6 @@
 require 'concurrent/errors'
 require 'concurrent/executor/executor_service'
 require 'concurrent/synchronization'
-require 'concurrent/utility/at_exit'
 
 module Concurrent
 
@@ -18,6 +17,8 @@ class AbstractExecutorService < Synchronization::LockableObject
 
     attr_reader :name
 
+    attr_accessor :ns_auto_terminate
+
     # Create a new thread pool.
     def initialize(opts = {}, &block)
       super(&nil)
@@ -119,25 +120,8 @@ def ns_kill_execution
     end
 
     def ns_auto_terminate?
-      !!@auto_terminate
-    end
-
-    def ns_auto_terminate=(value)
-      case value
-      when true
-        AT_EXIT.add(self) { terminate_at_exit }
-        @auto_terminate = true
-      when false
-        AT_EXIT.delete(self)
-        @auto_terminate = false
-      else
-        raise ArgumentError
-      end
+      !!ns_auto_terminate
     end
 
-    def terminate_at_exit
-      kill # TODO be gentle first
-      wait_for_termination(10)
-    end
   end
 end

lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb

@@ -121,9 +121,7 @@ module Concurrent
   #   * `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:
@@ -148,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.
@@ -166,7 +160,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-
 
 
 

lib/concurrent-ruby/concurrent/utility/at_exit.rb

@@ -19,13 +19,6 @@ module Concurrent
         expect(Concurrent.global_io_executor).to respond_to(:post)
       end
 
-      specify 'Concurrent::AtExit.run acts on all executors with auto_terminate: true' do
-        # The 'at_least(:once)' clauses account for global config reset
-        expect(Concurrent.global_fast_executor).to receive(:kill).at_least(:once).with(no_args)
-        expect(Concurrent.global_io_executor).to receive(:kill).at_least(:once).with(no_args)
-        expect(Concurrent.global_timer_set).to receive(:kill).at_least(:once).with(no_args)
-        Concurrent::AT_EXIT.run
-      end
     end
    end
 end

spec/concurrent/configuration_spec.rb

@@ -4,8 +4,6 @@
 
 require 'concurrent-ruby'
 
-# the test relies on replicating that Minitest messed up the AtExit handling
-Concurrent.disable_at_exit_handlers!
 pool = Concurrent::CachedThreadPool.new
 pool.post do
   sleep # sleep indefinitely