concurrent-ruby 0.9.2 → 1.0.0.pre1

data/lib/concurrent/executor/abstract_executor_service.rb

@@ -0,0 +1,134 @@
+require 'concurrent/errors'
+require 'concurrent/executor/executor_service'
+require 'concurrent/synchronization/object'
+require 'concurrent/utility/at_exit'
+
+module Concurrent
+
+  # @!macro abstract_executor_service_public_api
+  # @!visibility private
+  class AbstractExecutorService < Synchronization::Object
+    include ExecutorService
+
+    # The set of possible fallback policies that may be set at thread pool creation.
+    FALLBACK_POLICIES = [:abort, :discard, :caller_runs].freeze
+
+    # @!macro executor_service_attr_reader_fallback_policy
+    attr_reader :fallback_policy
+
+    # Create a new thread pool.
+    def initialize(*args, &block)
+      super(&nil)
+      synchronize { ns_initialize(*args, &block) }
+    end
+
+    # @!macro executor_service_method_shutdown
+    def shutdown
+      raise NotImplementedError
+    end
+
+    # @!macro executor_service_method_kill
+    def kill
+      raise NotImplementedError
+    end
+
+    # @!macro executor_service_method_wait_for_termination
+    def wait_for_termination(timeout = nil)
+      raise NotImplementedError
+    end
+
+    # @!macro executor_service_method_running_question
+    def running?
+      synchronize { ns_running? }
+    end
+
+    # @!macro executor_service_method_shuttingdown_question
+    def shuttingdown?
+      synchronize { ns_shuttingdown? }
+    end
+
+    # @!macro executor_service_method_shutdown_question
+    def shutdown?
+      synchronize { ns_shutdown? }
+    end
+
+    # @!macro executor_service_method_auto_terminate_question
+    def auto_terminate?
+      synchronize { ns_auto_terminate? }
+    end
+
+    # @!macro executor_service_method_auto_terminate_setter
+    def auto_terminate=(value)
+      synchronize { self.ns_auto_terminate = value }
+    end
+
+    private
+
+    # Handler which executes the `fallback_policy` once the queue size
+    # reaches `max_queue`.
+    #
+    # @param [Array] args the arguments to the task which is being handled.
+    #
+    # @!visibility private
+    def handle_fallback(*args)
+      case fallback_policy
+      when :abort
+        raise RejectedExecutionError
+      when :discard
+        false
+      when :caller_runs
+        begin
+          yield(*args)
+        rescue => ex
+          # let it fail
+          log DEBUG, ex
+        end
+        true
+      else
+        fail "Unknown fallback policy #{fallback_policy}"
+      end
+    end
+
+    def ns_execute(*args, &task)
+      raise NotImplementedError
+    end
+
+    # @!macro [attach] executor_service_method_ns_shutdown_execution
+    #
+    #   Callback method called when an orderly shutdown has completed.
+    #   The default behavior is to signal all waiting threads.
+    def ns_shutdown_execution
+      # do nothing
+    end
+
+    # @!macro [attach] executor_service_method_ns_kill_execution
+    #
+    #   Callback method called when the executor has been killed.
+    #   The default behavior is to do nothing.
+    def ns_kill_execution
+      # do nothing
+    end
+
+    def ns_auto_terminate?
+      !!@auto_terminate
+    end
+
+    def ns_auto_terminate=(value)
+      case value
+      when true
+        AtExit.add(self) { terminate_at_exit }
+        @auto_terminate = true
+      when false
+        AtExit.delete(self)
+        @auto_terminate = false
+      else
+        raise ArgumentError
+      end
+    end
+
+    def terminate_at_exit
+      kill # TODO be gentle first
+      wait_for_termination(10)
+    end
+  end
+end

data/lib/concurrent/executor/executor.rb

@@ -1,12 +1,10 @@
-require 'concurrent/configuration'
-require 'concurrent/concern/deprecation'
-require 'concurrent/executor/executor_service'
+# This file has circular require issues. For now we assume all
+# necessary dependencies have been required already.
 
 module Concurrent
 
   # @!visibility private
   module Executor
-    extend Concern::Deprecation
 
     # Get the requested `Executor` based on the values set in the options hash.
     #
@@ -20,25 +18,8 @@ module Concurrent
     #
     # @!visibility private
     def self.executor_from_options(opts = {}) # :nodoc:
-      case
-      when opts.key?(:executor)
-        if opts[:executor].nil?
-          nil
-        else
-          executor(opts[:executor])
-        end
-      when opts.key?(:operation) || opts.key?(:task)
-        if opts[:operation] == true || opts[:task] == false
-          deprecated 'use `executor: :fast` instead'
-          return Concurrent.global_fast_executor
-        end
-
-        if opts[:operation] == false || opts[:task] == true
-          deprecated 'use `executor: :io` instead'
-          return Concurrent.global_io_executor
-        end
-
-        raise ArgumentError.new("executor '#{opts[:executor]}' not recognized")
+      if identifier = opts.fetch(:executor, nil)
+        executor(identifier)
       else
         nil
       end
@@ -52,12 +33,6 @@ module Concurrent
         Concurrent.global_io_executor
       when :immediate
         Concurrent.global_immediate_executor
-      when :operation
-        deprecated 'use `executor: :fast` instead'
-        Concurrent.global_fast_executor
-      when :task
-        deprecated 'use `executor: :io` instead'
-        Concurrent.global_io_executor
       when Concurrent::ExecutorService
         executor_identifier
       else

data/lib/concurrent/executor/executor_service.rb

@@ -1,12 +1,9 @@
-require 'concurrent/errors'
-require 'concurrent/concern/deprecation'
 require 'concurrent/concern/logging'
-require 'concurrent/atomic/event'
-require 'concurrent/synchronization'
-require 'concurrent/utility/at_exit'
 
 module Concurrent
 
+  ###################################################################
+
   # @!macro [new] executor_service_method_post
   #
   #   Submit a task to the executor for asynchronous processing.
@@ -42,9 +39,7 @@ module Concurrent
   #     will be post in the order they are received and no two operations may
   #     occur simultaneously. Else false.
 
-
-
-
+  ###################################################################
 
   # @!macro [new] executor_service_public_api
   #
@@ -60,75 +55,7 @@ module Concurrent
   #   @!method serialized?
   #     @!macro executor_service_method_serialized_question
 
-
-
-
-
-  # @!macro executor_service_public_api
-  # @!visibility private
-  module ExecutorService
-    include Concern::Logging
-    include Concern::Deprecation
-
-    # @!macro executor_service_method_post
-    def post(*args, &task)
-      raise NotImplementedError
-    end
-
-    # @!macro executor_service_method_left_shift
-    def <<(task)
-      post(&task)
-      self
-    end
-
-    # @!macro executor_service_method_can_overflow_question
-    #
-    # @note Always returns `false`
-    def can_overflow?
-      false
-    end
-
-    # @!macro executor_service_method_serialized_question
-    #
-    # @note Always returns `false`
-    def serialized?
-      false
-    end
-  end
-
-  # Indicates that the including `ExecutorService` guarantees
-  # that all operations will occur in the order they are post and that no
-  # two operations may occur simultaneously. This module provides no
-  # functionality and provides no guarantees. That is the responsibility
-  # of the including class. This module exists solely to allow the including
-  # object to be interrogated for its serialization status.
-  #
-  # @example
-  #   class Foo
-  #     include Concurrent::SerialExecutor
-  #   end
-  #
-  #   foo = Foo.new
-  #
-  #   foo.is_a? Concurrent::ExecutorService #=> true
-  #   foo.is_a? Concurrent::SerialExecutor  #=> true
-  #   foo.serialized?                       #=> true
-  #
-  # @!visibility private
-  module SerialExecutorService
-    include ExecutorService
-
-    # @!macro executor_service_method_serialized_question
-    #
-    # @note Always returns `true`
-    def serialized?
-      true
-    end
-  end
-
-
-
-
+  ###################################################################
 
   # @!macro [new] executor_service_attr_reader_fallback_policy
   #   @return [Symbol] The fallback policy in effect. Either `:abort`, `:discard`, or `:caller_runs`.
@@ -190,9 +117,7 @@ module Concurrent
   #
   #   @return [Boolean] `true` when auto-termination is enabled else `false`.
 
-
-
-
+  ###################################################################
 
   # @!macro [new] abstract_executor_service_public_api
   #
@@ -225,297 +150,36 @@ module Concurrent
   #   @!method auto_terminate=(value)
   #     @!macro executor_service_method_auto_terminate_setter
 
+  ###################################################################
 
-
-
-
-  # @!macro abstract_executor_service_public_api
+  # @!macro executor_service_public_api
   # @!visibility private
-  class AbstractExecutorService < Synchronization::Object
-    include ExecutorService
-
-    # The set of possible fallback policies that may be set at thread pool creation.
-    FALLBACK_POLICIES = [:abort, :discard, :caller_runs].freeze
-
-    # @!macro [attach] executor_service_attr_reader_fallback_policy
-    attr_reader :fallback_policy
-
-    # Create a new thread pool.
-    def initialize(*args, &block)
-      super(&nil)
-      synchronize { ns_initialize(*args, &block) }
-    end
-
-    # @!macro [attach] executor_service_method_shutdown
-    def shutdown
-      raise NotImplementedError
-    end
-
-    # @!macro [attach] executor_service_method_kill
-    def kill
-      raise NotImplementedError
-    end
+  module ExecutorService
+    include Concern::Logging
 
-    # @!macro [attach] executor_service_method_wait_for_termination
-    def wait_for_termination(timeout = nil)
+    # @!macro executor_service_method_post
+    def post(*args, &task)
       raise NotImplementedError
     end
 
-    # @!macro [attach] executor_service_method_running_question
-    def running?
-      synchronize { ns_running? }
-    end
-
-    # @!macro [attach] executor_service_method_shuttingdown_question
-    def shuttingdown?
-      synchronize { ns_shuttingdown? }
-    end
-
-    # @!macro [attach] executor_service_method_shutdown_question
-    def shutdown?
-      synchronize { ns_shutdown? }
-    end
-
-    # @!macro [attach] executor_service_method_auto_terminate_question
-    def auto_terminate?
-      synchronize { ns_auto_terminate? }
-    end
-
-    # @!macro [attach] executor_service_method_auto_terminate_setter
-    def auto_terminate=(value)
-      synchronize { self.ns_auto_terminate = value }
-    end
-
-    protected
-
-    # Handler which executes the `fallback_policy` once the queue size
-    # reaches `max_queue`.
-    #
-    # @param [Array] args the arguments to the task which is being handled.
-    #
-    # @!visibility private
-    def handle_fallback(*args)
-      case fallback_policy
-      when :abort
-        raise RejectedExecutionError
-      when :discard
-        false
-      when :caller_runs
-        begin
-          yield(*args)
-        rescue => ex
-          # let it fail
-          log DEBUG, ex
-        end
-        true
-      else
-        fail "Unknown fallback policy #{fallback_policy}"
-      end
-    end
-
-    def execute(*args, &task)
-      raise NotImplementedError
+    # @!macro executor_service_method_left_shift
+    def <<(task)
+      post(&task)
+      self
     end
 
-    # @!macro [attach] executor_service_method_shutdown_execution
+    # @!macro executor_service_method_can_overflow_question
     #
-    #   Callback method called when an orderly shutdown has completed.
-    #   The default behavior is to signal all waiting threads.
-    def shutdown_execution
-      # do nothing
+    # @note Always returns `false`
+    def can_overflow?
+      false
     end
 
-    # @!macro [attach] executor_service_method_kill_execution
+    # @!macro executor_service_method_serialized_question
     #
-    #   Callback method called when the executor has been killed.
-    #   The default behavior is to do nothing.
-    def kill_execution
-      # do nothing
-    end
-
-    protected
-
-    def ns_auto_terminate?
-      !!@auto_terminate
-    end
-
-    def ns_auto_terminate=(value)
-      case value
-      when true
-        AtExit.add(self) { terminate_at_exit }
-        @auto_terminate = true
-      when false
-        AtExit.delete(self)
-        @auto_terminate = false
-      else
-        raise ArgumentError
-      end
-    end
-
-    def terminate_at_exit
-      kill # TODO be gentle first
-      wait_for_termination(10)
-    end
-  end
-
-  # @!macro abstract_executor_service_public_api
-  # @!visibility private
-  class RubyExecutorService < AbstractExecutorService
-
-    def initialize(*args, &block)
-      super
-      @stop_event    = Event.new
-      @stopped_event = Event.new
-      ensure_ivar_visibility!
-    end
-
-    def post(*args, &task)
-      raise ArgumentError.new('no block given') unless block_given?
-      synchronize do
-        # If the executor is shut down, reject this task
-        return handle_fallback(*args, &task) unless running?
-        execute(*args, &task)
-        true
-      end
-    end
-
-    def shutdown
-      synchronize do
-        break unless running?
-        self.ns_auto_terminate = false
-        stop_event.set
-        shutdown_execution
-      end
-      true
-    end
-
-    def kill
-      synchronize do
-        break if shutdown?
-        self.ns_auto_terminate = false
-        stop_event.set
-        kill_execution
-        stopped_event.set
-      end
-      true
-    end
-
-    def wait_for_termination(timeout = nil)
-      stopped_event.wait(timeout)
-    end
-
-    protected
-
-    attr_reader :stop_event, :stopped_event
-
-    def shutdown_execution
-      stopped_event.set
-    end
-
-    def ns_running?
-      !stop_event.set?
-    end
-
-    def ns_shuttingdown?
-      !(ns_running? || ns_shutdown?)
-    end
-
-    def ns_shutdown?
-      stopped_event.set?
-    end
-  end
-
-  if Concurrent.on_jruby?
-
-    # @!macro abstract_executor_service_public_api
-    # @!visibility private
-    class JavaExecutorService < AbstractExecutorService
-      java_import 'java.lang.Runnable'
-
-      FALLBACK_POLICY_CLASSES = {
-        abort:       java.util.concurrent.ThreadPoolExecutor::AbortPolicy,
-        discard:     java.util.concurrent.ThreadPoolExecutor::DiscardPolicy,
-        caller_runs: java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
-      }.freeze
-      private_constant :FALLBACK_POLICY_CLASSES
-
-      def initialize(*args, &block)
-        super
-        ns_make_executor_runnable
-      end
-
-      def post(*args, &task)
-        raise ArgumentError.new('no block given') unless block_given?
-        return handle_fallback(*args, &task) unless running?
-        @executor.submit_runnable Job.new(args, task)
-        true
-      rescue Java::JavaUtilConcurrent::RejectedExecutionException
-        raise RejectedExecutionError
-      end
-
-      def wait_for_termination(timeout = nil)
-        if timeout.nil?
-          ok = @executor.awaitTermination(60, java.util.concurrent.TimeUnit::SECONDS) until ok
-          true
-        else
-          @executor.awaitTermination(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
-        end
-      end
-
-      def shutdown
-        synchronize do
-          self.ns_auto_terminate = false
-          @executor.shutdown
-          nil
-        end
-      end
-
-      def kill
-        synchronize do
-          self.ns_auto_terminate = false
-          @executor.shutdownNow
-          nil
-        end
-      end
-
-      protected
-
-      def ns_running?
-        !(ns_shuttingdown? || ns_shutdown?)
-      end
-
-      def ns_shuttingdown?
-        if @executor.respond_to? :isTerminating
-          @executor.isTerminating
-        else
-          false
-        end
-      end
-
-      def ns_shutdown?
-        @executor.isShutdown || @executor.isTerminated
-      end
-
-      def ns_make_executor_runnable
-        if !defined?(@executor.submit_runnable)
-          @executor.class.class_eval do
-            java_alias :submit_runnable, :submit, [java.lang.Runnable.java_class]
-          end
-        end
-      end
-
-      class Job
-        include Runnable
-        def initialize(args, block)
-          @args = args
-          @block = block
-        end
-
-        def run
-          @block.call(*@args)
-        end
-      end
-      private_constant :Job
+    # @note Always returns `false`
+    def serialized?
+      false
     end
   end
 end