concurrent-ruby 0.8.0.pre2-java → 0.9.0-java

data/lib/concurrent/executor/ruby_single_thread_executor.rb

@@ -1,31 +1,29 @@
-require_relative 'executor'
+require 'concurrent/executor/executor_service'
 
 module Concurrent
 
   # @!macro single_thread_executor
-  class RubySingleThreadExecutor
-    include RubyExecutor
-    include SerialExecutor
+  # @!macro thread_pool_options
+  # @!macro abstract_executor_service_public_api
+  # @!visibility private
+  class RubySingleThreadExecutor < RubyExecutorService
+    include SerialExecutorService
 
-    # Create a new thread pool.
-    #
-    # @option opts [Symbol] :fallback_policy (:discard) the policy for
-    #   handling new tasks that are received when the queue size has
-    #   reached `max_queue` or after the executor has shut down
-    #
-    # @see http://docs.oracle.com/javase/tutorial/essential/concurrency/pools.html
-    # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Executors.html
-    # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html
+    # @!macro single_thread_executor_method_initialize
     def initialize(opts = {})
+      super
+    end
+
+    protected
+
+    def ns_initialize(opts)
       @queue = Queue.new
       @thread = nil
       @fallback_policy = opts.fetch(:fallback_policy, :discard)
       raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
-      init_executor
+      self.auto_terminate = opts.fetch(:auto_terminate, true)
     end
 
-    protected
-
     # @!visibility private
     def execute(*args, &task)
       supervise

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -1,261 +1,345 @@
 require 'thread'
 
-require_relative 'executor'
 require 'concurrent/atomic/event'
-require 'concurrent/executor/ruby_thread_pool_worker'
+require 'concurrent/concern/logging'
+require 'concurrent/executor/executor_service'
+require 'concurrent/utility/monotonic_time'
 
 module Concurrent
 
   # @!macro thread_pool_executor
-  class RubyThreadPoolExecutor
-    include RubyExecutor
+  # @!macro thread_pool_options
+  # @!visibility private
+  class RubyThreadPoolExecutor < RubyExecutorService
 
-    # Default maximum number of threads that will be created in the pool.
-    DEFAULT_MAX_POOL_SIZE      = 2**15 # 32768
+    # @!macro thread_pool_executor_constant_default_max_pool_size
+    DEFAULT_MAX_POOL_SIZE      = 2_147_483_647 # java.lang.Integer::MAX_VALUE
 
-    # Default minimum number of threads that will be retained in the pool.
+    # @!macro thread_pool_executor_constant_default_min_pool_size
     DEFAULT_MIN_POOL_SIZE      = 0
 
-    # Default maximum number of tasks that may be added to the task queue.
+    # @!macro thread_pool_executor_constant_default_max_queue_size
     DEFAULT_MAX_QUEUE_SIZE     = 0
 
-    # Default maximum number of seconds a thread in the pool may remain idle
-    # before being reclaimed.
+    # @!macro thread_pool_executor_constant_default_thread_timeout
     DEFAULT_THREAD_IDLETIMEOUT = 60
 
-    # The maximum number of threads that may be created in the pool.
+    # @!macro thread_pool_executor_attr_reader_max_length
     attr_reader :max_length
 
-    # The minimum number of threads that may be retained in the pool.
+    # @!macro thread_pool_executor_attr_reader_min_length
     attr_reader :min_length
 
-    # The largest number of threads that have been created in the pool since construction.
+    # @!macro thread_pool_executor_attr_reader_largest_length
     attr_reader :largest_length
 
-    # The number of tasks that have been scheduled for execution on the pool since construction.
+    # @!macro thread_pool_executor_attr_reader_scheduled_task_count
     attr_reader :scheduled_task_count
 
-    # The number of tasks that have been completed by the pool since construction.
+    # @!macro thread_pool_executor_attr_reader_completed_task_count
     attr_reader :completed_task_count
 
-    # The number of seconds that a thread may be idle before being reclaimed.
+    # @!macro thread_pool_executor_attr_reader_idletime
     attr_reader :idletime
 
-    # 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`.
+    # @!macro thread_pool_executor_attr_reader_max_queue
     attr_reader :max_queue
 
-    # Create a new thread pool.
-    #
-    # @param [Hash] opts the options which configure the thread pool
-    #
-    # @option opts [Integer] :max_threads (DEFAULT_MAX_POOL_SIZE) the maximum
-    #   number of threads to be created
-    # @option opts [Integer] :min_threads (DEFAULT_MIN_POOL_SIZE) the minimum
-    #   number of threads to be retained
-    # @option opts [Integer] :idletime (DEFAULT_THREAD_IDLETIMEOUT) the maximum
-    #   number of seconds a thread may be idle before being reclaimed
-    # @option opts [Integer] :max_queue (DEFAULT_MAX_QUEUE_SIZE) the maximum
-    #   number of tasks allowed in the work queue at any one time; a value of
-    #   zero means the queue may grow without bound
-    # @option opts [Symbol] :fallback_policy (:abort) the policy for handling new
-    #   tasks that are received when the queue size has reached
-    #   `max_queue` or the executor has shut down
-    #
-    # @raise [ArgumentError] if `:max_threads` is less than one
-    # @raise [ArgumentError] if `:min_threads` is less than zero
-    # @raise [ArgumentError] if `:fallback_policy` is not one of the values specified
-    #   in `FALLBACK_POLICIES`
-    #
-    # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html
+    # @!macro thread_pool_executor_method_initialize
     def 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
-      @fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
-      warn '[DEPRECATED] :overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
-
-      raise ArgumentError.new('max_threads must be greater than zero') if @max_length <= 0
-      raise ArgumentError.new('min_threads cannot be less than zero') if @min_length < 0
-      raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
-      raise ArgumentError.new('min_threads cannot be more than max_threads') if min_length > max_length
-
-      init_executor
-
-      @pool                 = []
-      @queue                = Queue.new
-      @scheduled_task_count = 0
-      @completed_task_count = 0
-      @largest_length       = 0
-
-      @gc_interval  = opts.fetch(:gc_interval, 1).to_i # undocumented
-      @last_gc_time = Time.now.to_f - [1.0, (@gc_interval * 2.0)].max
+      super(opts)
     end
 
-    # @!macro executor_module_method_can_overflow_question
+    # @!macro executor_service_method_can_overflow_question
     def can_overflow?
-      @max_queue != 0
+      synchronize { ns_limited_queue? }
     end
 
-    # The number of threads currently in the pool.
-    #
-    # @return [Integer] the length
+    # @!macro thread_pool_executor_attr_reader_length
     def length
-      mutex.synchronize { running? ? @pool.length : 0 }
+      synchronize { @pool.length }
     end
 
-    alias_method :current_length, :length
-
-    # The number of tasks in the queue awaiting execution.
-    #
-    # @return [Integer] the queue_length
+    # @!macro thread_pool_executor_attr_reader_queue_length
     def queue_length
-      mutex.synchronize { running? ? @queue.length : 0 }
+      synchronize { @queue.length }
     end
 
-    # 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.
-    #
-    # @return [Integer] the remaining_capacity
+    # @!macro thread_pool_executor_attr_reader_remaining_capacity
     def remaining_capacity
-      mutex.synchronize { @max_queue == 0 ? -1 : @max_queue - @queue.length }
+      synchronize do
+        if ns_limited_queue?
+          @max_queue - @queue.length
+        else
+          -1
+        end
+      end
     end
 
-    # Returns an array with the status of each thread in the pool
-    #
-    # This method is deprecated and will be removed soon.
-    def status
-      warn '[DEPRECATED] `status` is deprecated and will be removed soon.'
-      mutex.synchronize { @pool.collect { |worker| worker.status } }
+    # @!visibility private
+    def remove_busy_worker(worker)
+      synchronize { ns_remove_busy_worker worker }
     end
 
-    # Run on task completion.
-    #
     # @!visibility private
-    def on_end_task
-      mutex.synchronize do
-        @completed_task_count += 1 #if success
-        break unless running?
-      end
+    def ready_worker(worker)
+      synchronize { ns_ready_worker worker }
     end
 
-    # Run when a thread worker exits.
-    #
     # @!visibility private
-    def on_worker_exit(worker)
-      mutex.synchronize do
-        @pool.delete(worker)
-        if @pool.empty? && !running?
-          stop_event.set
-          stopped_event.set
-        end
-      end
+    def worker_not_old_enough(worker)
+      synchronize { ns_worker_not_old_enough worker }
+    end
+
+    # @!visibility private
+    def worker_died(worker)
+      synchronize { ns_worker_died worker }
     end
 
     protected
 
     # @!visibility private
-    def execute(*args, &task)
-      prune_pool
-      if ensure_capacity?
+    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
+      @fallback_policy = opts.fetch(:fallback_policy, opts.fetch(:overflow_policy, :abort))
+      raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICIES.include?(@fallback_policy)
+      deprecated ':overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
+
+      raise ArgumentError.new("`max_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @max_length < DEFAULT_MIN_POOL_SIZE
+      raise ArgumentError.new("`max_threads` cannot be greater than #{DEFAULT_MAX_POOL_SIZE}") if @max_length > DEFAULT_MAX_POOL_SIZE
+      raise ArgumentError.new("`min_threads` cannot be less than #{DEFAULT_MIN_POOL_SIZE}") if @min_length < DEFAULT_MIN_POOL_SIZE
+      raise ArgumentError.new("`min_threads` cannot be more than `max_threads`") if min_length > max_length
+
+      self.auto_terminate = opts.fetch(:auto_terminate, true)
+
+      @pool                 = [] # all workers
+      @ready                = [] # used as a stash (most idle worker is at the start)
+      @queue                = [] # used as queue
+      # @ready or @queue is empty at all times
+      @scheduled_task_count = 0
+      @completed_task_count = 0
+      @largest_length       = 0
+
+      @gc_interval  = opts.fetch(:gc_interval, @idletime / 2.0).to_i # undocumented
+      @next_gc_time = Concurrent.monotonic_time + @gc_interval
+    end
+
+    # @!visibility private
+    def ns_limited_queue?
+      @max_queue != 0
+    end
+
+    # @!visibility private
+    def ns_execute(*args, &task)
+      if ns_assign_worker(*args, &task) || ns_enqueue(*args, &task)
         @scheduled_task_count += 1
-        @queue << [args, task]
       else
-        handle_fallback(*args, &task) if @max_queue != 0 && @queue.length >= @max_queue
+        handle_fallback(*args, &task)
       end
+
+      ns_prune_pool if @next_gc_time < Concurrent.monotonic_time
+      # raise unless @ready.empty? || @queue.empty? # assert
     end
 
+    alias_method :execute, :ns_execute
+
     # @!visibility private
-    def shutdown_execution
+    def ns_shutdown_execution
       if @pool.empty?
+        # nothing to do
         stopped_event.set
-      else
-        @pool.length.times { @queue << :stop }
       end
+      if @queue.empty?
+        # no more tasks will be accepted, just stop all workers
+        @pool.each(&:stop)
+      end
+
+      # raise unless @ready.empty? || @queue.empty? # assert
     end
 
+    alias_method :shutdown_execution, :ns_shutdown_execution
+
     # @!visibility private
-    def kill_execution
-      @queue.clear
-      drain_pool
+    def ns_kill_execution
+      # TODO log out unprocessed tasks in queue
+      # TODO try to shutdown first?
+      @pool.each &:kill
+      @pool.clear
+      @ready.clear
     end
 
-    # Check the thread pool configuration and determine if the pool
-    # has enought capacity to handle the request. Will grow the size
-    # of the pool if necessary.
-    #
-    # @return [Boolean] true if the pool has enough capacity else false
+    alias_method :kill_execution, :ns_kill_execution
+
+    # tries to assign task to a worker, tries to get one from @ready or to create new one
+    # @return [true, false] if task is assigned to a worker
     #
     # @!visibility private
-    def ensure_capacity?
-      additional = 0
-      capacity   = true
-
-      if @pool.size < @min_length
-        additional = @min_length - @pool.size
-      elsif @queue.empty? && @queue.num_waiting >= 1
-        additional = 0
-      elsif @pool.size == 0 && @min_length == 0
-        additional = 1
-      elsif @pool.size < @max_length || @max_length == 0
-        additional = 1
-      elsif @max_queue == 0 || @queue.size < @max_queue
-        additional = 0
+    def ns_assign_worker(*args, &task)
+      # keep growing if the pool is not at the minimum yet
+      worker = (@ready.pop if @pool.size >= @min_length) || ns_add_busy_worker
+      if worker
+        worker << [task, args]
+        true
       else
-        capacity = false
+        false
       end
+    rescue ThreadError
+      # Raised when the operating system refuses to create the new thread
+      return false
+    end
 
-      additional.times do
-        @pool << create_worker_thread
+    # tries to enqueue task
+    # @return [true, false] if enqueued
+    #
+    # @!visibility private
+    def ns_enqueue(*args, &task)
+      if !ns_limited_queue? || @queue.size < @max_queue
+        @queue << [task, args]
+        true
+      else
+        false
       end
+    end
 
-      if additional > 0
-        @largest_length = [@largest_length, @pool.length].max
-      end
+    # @!visibility private
+    def ns_worker_died(worker)
+      ns_remove_busy_worker worker
+      replacement_worker = ns_add_busy_worker
+      ns_ready_worker replacement_worker, false if replacement_worker
+    end
+
+    # creates new worker which has to receive work to do after it's added
+    # @return [nil, Worker] nil of max capacity is reached
+    #
+    # @!visibility private
+    def ns_add_busy_worker
+      return if @pool.size >= @max_length
 
-      capacity
+      @pool << (worker = Worker.new(self))
+      @largest_length = @pool.length if @pool.length > @largest_length
+      worker
     end
 
-    # Scan all threads in the pool and reclaim any that are dead or
-    # have been idle too long. Will check the last time the pool was
-    # pruned and only run if the configured garbage collection
-    # interval has passed.
+    # handle ready worker, giving it new job or assigning back to @ready
     #
     # @!visibility private
-    def prune_pool
-      if Time.now.to_f - @gc_interval >= @last_gc_time
-        @pool.delete_if { |worker| worker.dead? }
-        # send :stop for each thread over idletime
-        @pool.
-            select { |worker| @idletime != 0 && Time.now.to_f - @idletime > worker.last_activity }.
-            each { @queue << :stop }
-        @last_gc_time = Time.now.to_f
+    def ns_ready_worker(worker, success = true)
+      @completed_task_count += 1 if success
+      task_and_args         = @queue.shift
+      if task_and_args
+        worker << task_and_args
+      else
+        # stop workers when !running?, do not return them to @ready
+        if running?
+          @ready.push(worker)
+        else
+          worker.stop
+        end
       end
     end
 
-    # Reclaim all threads in the pool.
+    # returns back worker to @ready which was not idle for enough time
     #
     # @!visibility private
-    def drain_pool
-      @pool.each { |worker| worker.kill }
-      @pool.clear
+    def ns_worker_not_old_enough(worker)
+      # let's put workers coming from idle_test back to the start (as the oldest worker)
+      @ready.unshift(worker)
+      true
     end
 
-    # Create a single worker thread to be added to the pool.
+    # removes a worker which is not in not tracked in @ready
     #
-    # @return [Thread] the new thread.
+    # @!visibility private
+    def ns_remove_busy_worker(worker)
+      @pool.delete(worker)
+      stopped_event.set if @pool.empty? && !running?
+      true
+    end
+
+    # try oldest worker if it is idle for enough time, it's returned back at the start
     #
     # @!visibility private
-    def create_worker_thread
-      wrkr = RubyThreadPoolWorker.new(@queue, self)
-      Thread.new(wrkr, self) do |worker, parent|
-        Thread.current.abort_on_exception = false
-        worker.run
-        parent.on_worker_exit(worker)
+    def ns_prune_pool
+      return if @pool.size <= @min_length
+
+      last_used = @ready.shift
+      last_used << :idle_test if last_used
+
+      @next_gc_time = Concurrent.monotonic_time + @gc_interval
+    end
+
+    # @!visibility private
+    class Worker
+      include Concern::Logging
+
+      def initialize(pool)
+        # instance variables accessed only under pool's lock so no need to sync here again
+        @queue  = Queue.new
+        @pool   = pool
+        @thread = create_worker @queue, pool, pool.idletime
+      end
+
+      def <<(message)
+        @queue << message
+      end
+
+      def stop
+        @queue << :stop
+      end
+
+      def kill
+        @thread.kill
+      end
+
+      private
+
+      def create_worker(queue, pool, idletime)
+        Thread.new(queue, pool, idletime) do |queue, pool, idletime|
+          last_message = Concurrent.monotonic_time
+          catch(:stop) do
+            loop do
+
+              case message = queue.pop
+              when :idle_test
+                if (Concurrent.monotonic_time - last_message) > idletime
+                  pool.remove_busy_worker(self)
+                  throw :stop
+                else
+                  pool.worker_not_old_enough(self)
+                end
+
+              when :stop
+                pool.remove_busy_worker(self)
+                throw :stop
+
+              else
+                task, args = message
+                run_task pool, task, args
+                last_message = Concurrent.monotonic_time
+
+                pool.ready_worker(self)
+              end
+
+            end
+          end
+        end
+      end
+
+      def run_task(pool, task, args)
+        task.call(*args)
+      rescue => ex
+        # let it fail
+        log DEBUG, ex
+      rescue Exception => ex
+        log ERROR, ex
+        pool.worker_died(self)
+        throw :stop
       end
-      return wrkr
     end
+
+    private_constant :Worker
   end
 end