Introduce DaemonThreadFactory

Introduce a ThreadFactory that will set `Thread#setDaemon` according
to the _auto_terminate_ value.

This makes the need for the `AtExit` functionality uneeded since all
threads can now be started daemonized.

Furthermore, the gross **hack** of `Configuration#disable_at_exit_handlers!`
is especially not needed since this allows the JVM to properly terminate
even with minitest.

You can test this with:
```
ruby test/concurrent/executor/test_cached_thread_pool.rb
```

fixes #839
fixes #817

Author: fzakaria

lib/concurrent/executor/cached_thread_pool.rb

@@ -1,6 +1,5 @@
 require 'concurrent/utility/engine'
 require 'concurrent/executor/thread_pool_executor'
-
 module Concurrent
 
   # A thread pool that dynamically grows and shrinks to fit the current workload.
@@ -51,11 +50,11 @@ def initialize(opts = {})
     def ns_initialize(opts)
       super(opts)
       if Concurrent.on_jruby?
+        self.auto_terminate = opts.fetch(:auto_terminate, true)
         @max_queue = 0
-        @executor = java.util.concurrent.Executors.newCachedThreadPool
+        @executor = java.util.concurrent.Executors.newCachedThreadPool Concurrent::DaemonThreadFactory.new(self.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

lib/concurrent/executor/java_daemon_thread_factory.rb

@@ -0,0 +1,18 @@
+module Concurrent
+
+  class DaemonThreadFactory
+    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
+
+end

lib/concurrent/executor/java_thread_pool_executor.rb

@@ -108,15 +108,17 @@ def ns_initialize(opts)
           queue = java.util.concurrent.LinkedBlockingQueue.new(@max_queue)
         end
 
+        self.auto_terminate = opts.fetch(:auto_terminate, true)
+
         @executor = java.util.concurrent.ThreadPoolExecutor.new(
             min_length,
             max_length,
             idletime,
             java.util.concurrent.TimeUnit::SECONDS,
             queue,
+            Concurrent::DaemonThreadFactory.new(self.auto_terminate?),
             FALLBACK_POLICY_CLASSES[@fallback_policy].new)
 
-        self.auto_terminate = opts.fetch(:auto_terminate, true)
       end
     end
   end

lib/concurrent/executor/thread_pool_executor.rb

@@ -5,6 +5,7 @@ module Concurrent
 
   if Concurrent.on_jruby?
     require 'concurrent/executor/java_thread_pool_executor'
+    require 'concurrent/executor/java_daemon_thread_factory'
   end
 
   ThreadPoolExecutorImplementation = case

test/concurrent/executor/test_cached_thread_pool.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path("../../../lib", __dir__)
+
+require 'minitest/autorun'
+require 'concurrent'
+class CachedThreadPoolTest < Minitest::Test
+
+  def test_cached_thread_pool_does_not_impede_shutdown
+    pool = Concurrent::CachedThreadPool.new
+    pool.post do
+      sleep
+    end
+
+  end
+end