concurrent-ruby 1.1.5

data/lib/concurrent/executor/immediate_executor.rb

@@ -0,0 +1,66 @@
+require 'concurrent/atomic/event'
+require 'concurrent/executor/abstract_executor_service'
+require 'concurrent/executor/serial_executor_service'
+
+module Concurrent
+
+  # An executor service which runs all operations on the current thread,
+  # blocking as necessary. Operations are performed in the order they are
+  # received and no two operations can be performed simultaneously.
+  #
+  # This executor service exists mainly for testing an debugging. When used
+  # it immediately runs every `#post` operation on the current thread, blocking
+  # that thread until the operation is complete. This can be very beneficial
+  # during testing because it makes all operations deterministic.
+  #
+  # @note Intended for use primarily in testing and debugging.
+  class ImmediateExecutor < AbstractExecutorService
+    include SerialExecutorService
+
+    # Creates a new executor
+    def initialize
+      @stopped = Concurrent::Event.new
+    end
+
+    # @!macro executor_service_method_post
+    def post(*args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      task.call(*args)
+      true
+    end
+
+    # @!macro executor_service_method_left_shift
+    def <<(task)
+      post(&task)
+      self
+    end
+
+    # @!macro executor_service_method_running_question
+    def running?
+      ! shutdown?
+    end
+
+    # @!macro executor_service_method_shuttingdown_question
+    def shuttingdown?
+      false
+    end
+
+    # @!macro executor_service_method_shutdown_question
+    def shutdown?
+      @stopped.set?
+    end
+
+    # @!macro executor_service_method_shutdown
+    def shutdown
+      @stopped.set
+      true
+    end
+    alias_method :kill, :shutdown
+
+    # @!macro executor_service_method_wait_for_termination
+    def wait_for_termination(timeout = nil)
+      @stopped.wait(timeout)
+    end
+  end
+end

data/lib/concurrent/executor/indirect_immediate_executor.rb

@@ -0,0 +1,44 @@
+require 'concurrent/executor/immediate_executor'
+require 'concurrent/executor/simple_executor_service'
+
+module Concurrent
+  # An executor service which runs all operations on a new thread, blocking
+  # until it completes. Operations are performed in the order they are received
+  # and no two operations can be performed simultaneously.
+  #
+  # This executor service exists mainly for testing an debugging. When used it
+  # immediately runs every `#post` operation on a new thread, blocking the
+  # current thread until the operation is complete. This is similar to how the
+  # ImmediateExecutor works, but the operation has the full stack of the new
+  # thread at its disposal. This can be helpful when the operations will spawn
+  # more operations on the same executor and so on - such a situation might
+  # overflow the single stack in case of an ImmediateExecutor, which is
+  # inconsistent with how it would behave for a threaded executor.
+  #
+  # @note Intended for use primarily in testing and debugging.
+  class IndirectImmediateExecutor < ImmediateExecutor
+    # Creates a new executor
+    def initialize
+      super
+      @internal_executor = SimpleExecutorService.new
+    end
+
+    # @!macro executor_service_method_post
+    def post(*args, &task)
+      raise ArgumentError.new("no block given") unless block_given?
+      return false unless running?
+
+      event = Concurrent::Event.new
+      @internal_executor.post do
+        begin
+          task.call(*args)
+        ensure
+          event.set
+        end
+      end
+      event.wait
+
+      true
+    end
+  end
+end

data/lib/concurrent/executor/java_executor_service.rb

@@ -0,0 +1,91 @@
+if Concurrent.on_jruby?
+
+  require 'concurrent/errors'
+  require 'concurrent/utility/engine'
+  require 'concurrent/executor/abstract_executor_service'
+
+  module Concurrent
+
+    # @!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
+      end
+
+      def post(*args, &task)
+        raise ArgumentError.new('no block given') unless block_given?
+        return handle_fallback(*args, &task) unless running?
+        @executor.submit 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
+
+      private
+
+      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
+
+      class Job
+        include Runnable
+        def initialize(args, block)
+          @args = args
+          @block = block
+        end
+
+        def run
+          @block.call(*@args)
+        end
+      end
+      private_constant :Job
+    end
+  end
+end

data/lib/concurrent/executor/java_single_thread_executor.rb

@@ -0,0 +1,29 @@
+if Concurrent.on_jruby?
+
+  require 'concurrent/executor/java_executor_service'
+  require 'concurrent/executor/serial_executor_service'
+
+  module Concurrent
+
+    # @!macro single_thread_executor
+    # @!macro abstract_executor_service_public_api
+    # @!visibility private
+    class JavaSingleThreadExecutor < JavaExecutorService
+      include SerialExecutorService
+
+      # @!macro single_thread_executor_method_initialize
+      def initialize(opts = {})
+        super(opts)
+      end
+
+      private
+      
+      def ns_initialize(opts)
+        @executor = java.util.concurrent.Executors.newSingleThreadExecutor
+        @fallback_policy = opts.fetch(:fallback_policy, :discard)
+        raise ArgumentError.new("#{@fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICY_CLASSES.keys.include?(@fallback_policy)
+        self.auto_terminate = opts.fetch(:auto_terminate, true)
+      end
+    end
+  end
+end

data/lib/concurrent/executor/java_thread_pool_executor.rb

@@ -0,0 +1,123 @@
+if Concurrent.on_jruby?
+
+  require 'concurrent/executor/java_executor_service'
+
+  module Concurrent
+
+    # @!macro thread_pool_executor
+    # @!macro thread_pool_options
+    # @!visibility private
+    class JavaThreadPoolExecutor < JavaExecutorService
+
+      # @!macro thread_pool_executor_constant_default_max_pool_size
+      DEFAULT_MAX_POOL_SIZE = java.lang.Integer::MAX_VALUE # 2147483647
+
+      # @!macro thread_pool_executor_constant_default_min_pool_size
+      DEFAULT_MIN_POOL_SIZE = 0
+
+      # @!macro thread_pool_executor_constant_default_max_queue_size
+      DEFAULT_MAX_QUEUE_SIZE = 0
+
+      # @!macro thread_pool_executor_constant_default_thread_timeout
+      DEFAULT_THREAD_IDLETIMEOUT = 60
+
+      # @!macro thread_pool_executor_attr_reader_max_length
+      attr_reader :max_length
+
+      # @!macro thread_pool_executor_attr_reader_max_queue
+      attr_reader :max_queue
+
+      # @!macro thread_pool_executor_method_initialize
+      def initialize(opts = {})
+        super(opts)
+      end
+
+      # @!macro executor_service_method_can_overflow_question
+      def can_overflow?
+        @max_queue != 0
+      end
+
+      # @!macro thread_pool_executor_attr_reader_min_length
+      def min_length
+        @executor.getCorePoolSize
+      end
+
+      # @!macro thread_pool_executor_attr_reader_max_length
+      def max_length
+        @executor.getMaximumPoolSize
+      end
+
+      # @!macro thread_pool_executor_attr_reader_length
+      def length
+        @executor.getPoolSize
+      end
+
+      # @!macro thread_pool_executor_attr_reader_largest_length
+      def largest_length
+        @executor.getLargestPoolSize
+      end
+
+      # @!macro thread_pool_executor_attr_reader_scheduled_task_count
+      def scheduled_task_count
+        @executor.getTaskCount
+      end
+
+      # @!macro thread_pool_executor_attr_reader_completed_task_count
+      def completed_task_count
+        @executor.getCompletedTaskCount
+      end
+
+      # @!macro thread_pool_executor_attr_reader_idletime
+      def idletime
+        @executor.getKeepAliveTime(java.util.concurrent.TimeUnit::SECONDS)
+      end
+
+      # @!macro thread_pool_executor_attr_reader_queue_length
+      def queue_length
+        @executor.getQueue.size
+      end
+
+      # @!macro thread_pool_executor_attr_reader_remaining_capacity
+      def remaining_capacity
+        @max_queue == 0 ? -1 : @executor.getQueue.remainingCapacity
+      end
+
+      # @!macro executor_service_method_running_question
+      def running?
+        super && !@executor.isTerminating
+      end
+
+      private
+
+      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, :abort)
+
+        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
+        raise ArgumentError.new("#{fallback_policy} is not a valid fallback policy") unless FALLBACK_POLICY_CLASSES.include?(@fallback_policy)
+
+        if @max_queue == 0
+          queue = java.util.concurrent.LinkedBlockingQueue.new
+        else
+          queue = java.util.concurrent.LinkedBlockingQueue.new(@max_queue)
+        end
+
+        @executor = java.util.concurrent.ThreadPoolExecutor.new(
+            min_length,
+            max_length,
+            idletime,
+            java.util.concurrent.TimeUnit::SECONDS,
+            queue,
+            FALLBACK_POLICY_CLASSES[@fallback_policy].new)
+
+        self.auto_terminate = opts.fetch(:auto_terminate, true)
+      end
+    end
+  end
+end

data/lib/concurrent/executor/ruby_executor_service.rb

@@ -0,0 +1,78 @@
+require 'concurrent/executor/abstract_executor_service'
+require 'concurrent/atomic/event'
+
+module Concurrent
+
+  # @!macro abstract_executor_service_public_api
+  # @!visibility private
+  class RubyExecutorService < AbstractExecutorService
+    safe_initialization!
+
+    def initialize(*args, &block)
+      super
+      @StopEvent    = Event.new
+      @StoppedEvent = Event.new
+    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?
+        ns_execute(*args, &task)
+        true
+      end
+    end
+
+    def shutdown
+      synchronize do
+        break unless running?
+        self.ns_auto_terminate = false
+        stop_event.set
+        ns_shutdown_execution
+      end
+      true
+    end
+
+    def kill
+      synchronize do
+        break if shutdown?
+        self.ns_auto_terminate = false
+        stop_event.set
+        ns_kill_execution
+        stopped_event.set
+      end
+      true
+    end
+
+    def wait_for_termination(timeout = nil)
+      stopped_event.wait(timeout)
+    end
+
+    private
+
+    def stop_event
+      @StopEvent
+    end
+
+    def stopped_event
+      @StoppedEvent
+    end
+
+    def ns_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
+end

data/lib/concurrent/executor/ruby_single_thread_executor.rb

@@ -0,0 +1,22 @@
+require 'concurrent/executor/ruby_thread_pool_executor'
+
+module Concurrent
+
+  # @!macro single_thread_executor
+  # @!macro abstract_executor_service_public_api
+  # @!visibility private
+  class RubySingleThreadExecutor < RubyThreadPoolExecutor
+
+    # @!macro single_thread_executor_method_initialize
+    def initialize(opts = {})
+      super(
+        min_threads: 1,
+        max_threads: 1,
+        max_queue: 0,
+        idletime: DEFAULT_THREAD_IDLETIMEOUT,
+        fallback_policy: opts.fetch(:fallback_policy, :discard),
+        auto_terminate: opts.fetch(:auto_terminate, true)
+      )
+    end
+  end
+end