concurrent-ruby 0.7.0-java

data/lib/concurrent/executor/java_cached_thread_pool.rb

@@ -0,0 +1,31 @@
+if RUBY_PLATFORM == 'java'
+
+  require 'concurrent/executor/java_thread_pool_executor'
+
+  module Concurrent
+
+    # @!macro cached_thread_pool
+    class JavaCachedThreadPool < JavaThreadPoolExecutor
+
+      # Create a new thread pool.
+      #
+      # @param [Hash] opts the options defining pool behavior.
+      # @option opts [Symbol] :overflow_policy (`:abort`) the overflow policy
+      #
+      # @raise [ArgumentError] if `overflow_policy` is not a known policy
+      #
+      # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newCachedThreadPool--
+      def initialize(opts = {})
+        @overflow_policy = opts.fetch(:overflow_policy, :abort)
+        @max_queue = 0
+
+        raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+
+        @executor = java.util.concurrent.Executors.newCachedThreadPool
+        @executor.setRejectedExecutionHandler(OVERFLOW_POLICIES[@overflow_policy].new)
+
+        set_shutdown_hook
+      end
+    end
+  end
+end

data/lib/concurrent/executor/java_fixed_thread_pool.rb

@@ -0,0 +1,41 @@
+if RUBY_PLATFORM == 'java'
+
+  require 'concurrent/executor/java_thread_pool_executor'
+
+  module Concurrent
+
+    # @!macro fixed_thread_pool
+    class JavaFixedThreadPool < JavaThreadPoolExecutor
+
+      # Create a new thread pool.
+      #
+      # @param [Hash] opts the options defining pool behavior.
+      # @option opts [Symbol] :overflow_policy (`:abort`) the overflow policy
+      #
+      # @raise [ArgumentError] if `num_threads` is less than or equal to zero
+      # @raise [ArgumentError] if `overflow_policy` is not a known policy
+      #
+      # @see http://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Executors.html#newFixedThreadPool-int-
+      def initialize(num_threads, opts = {})
+
+        opts = {
+            min_threads: num_threads,
+            max_threads: num_threads
+        }.merge(opts)
+        super(opts)
+
+
+        #@overflow_policy = opts.fetch(:overflow_policy, :abort)
+        #@max_queue = 0
+        #
+        #raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
+        #raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+        #
+        #@executor = java.util.concurrent.Executors.newFixedThreadPool(num_threads)
+        #@executor.setRejectedExecutionHandler(OVERFLOW_POLICIES[@overflow_policy].new)
+
+        set_shutdown_hook
+      end
+    end
+  end
+end

data/lib/concurrent/executor/java_single_thread_executor.rb

@@ -0,0 +1,22 @@
+if RUBY_PLATFORM == 'java'
+  require_relative 'executor'
+
+  module Concurrent
+
+    # @!macro single_thread_executor
+    class JavaSingleThreadExecutor
+      include JavaExecutor
+      include SerialExecutor
+
+      # Create a new thread pool.
+      #
+      # @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
+      def initialize(opts = {})
+        @executor = java.util.concurrent.Executors.newSingleThreadExecutor
+        set_shutdown_hook
+      end
+    end
+  end
+end

data/lib/concurrent/executor/java_thread_pool_executor.rb

@@ -0,0 +1,180 @@
+if RUBY_PLATFORM == 'java'
+  require_relative 'executor'
+
+  module Concurrent
+
+    # @!macro thread_pool_executor
+    class JavaThreadPoolExecutor
+      include JavaExecutor
+
+      # Default maximum number of threads that will be created in the pool.
+      DEFAULT_MAX_POOL_SIZE = java.lang.Integer::MAX_VALUE # 2147483647
+
+      # Default minimum number of threads that will be retained in the pool.
+      DEFAULT_MIN_POOL_SIZE = 0
+
+      # Default maximum number of tasks that may be added to the task queue.
+      DEFAULT_MAX_QUEUE_SIZE = 0
+
+      # Default maximum number of seconds a thread in the pool may remain idle
+      # before being reclaimed.
+      DEFAULT_THREAD_IDLETIMEOUT = 60
+
+      # The set of possible overflow policies that may be set at thread pool creation.
+      OVERFLOW_POLICIES = {
+        abort: java.util.concurrent.ThreadPoolExecutor::AbortPolicy,
+        discard: java.util.concurrent.ThreadPoolExecutor::DiscardPolicy,
+        caller_runs: java.util.concurrent.ThreadPoolExecutor::CallerRunsPolicy
+      }.freeze
+
+      # The maximum number of threads that may be created in the pool.
+      attr_reader :max_length
+
+      # 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 `overflow_policy`.
+      attr_reader :max_queue
+
+      # The policy defining how rejected tasks (tasks received once the queue size reaches
+      # the configured `max_queue`) are handled. Must be one of the values specified in
+      # `OVERFLOW_POLICIES`.
+      attr_reader :overflow_policy
+
+      # 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 bounnd
+      # @option opts [Symbol] :overflow_policy (:abort) the policy for handling new
+      #   tasks that are received when the queue size has reached `max_queue`
+      #
+      # @raise [ArgumentError] if `:max_threads` is less than one
+      # @raise [ArgumentError] if `:min_threads` is less than zero
+      # @raise [ArgumentError] if `:overflow_policy` is not one of the values specified
+      #   in `OVERFLOW_POLICIES`
+      #
+      # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/ThreadPoolExecutor.html
+      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
+        @overflow_policy = opts.fetch(:overflow_policy, :abort)
+
+        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('min_threads cannot be more than max_threads') if min_length > max_length
+        raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+
+        if min_length == 0 && @max_queue == 0
+          queue = java.util.concurrent.SynchronousQueue.new
+        elsif @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, OVERFLOW_POLICIES[@overflow_policy].new)
+
+        set_shutdown_hook
+      end
+
+    # @!macro executor_module_method_can_overflow_question
+      def can_overflow?
+        @max_queue != 0
+      end
+
+      # The minimum number of threads that may be retained in the pool.
+      #
+      # @return [Integer] the min_length
+      def min_length
+        @executor.getCorePoolSize
+      end
+
+      # The maximum number of threads that may be created in the pool.
+      #
+      # @return [Integer] the max_length
+      def max_length
+        @executor.getMaximumPoolSize
+      end
+
+      # The number of threads currently in the pool.
+      #
+      # @return [Integer] the length
+      def length
+        @executor.getPoolSize
+      end
+      alias_method :current_length, :length
+
+      # The largest number of threads that have been created in the pool since construction.
+      #
+      # @return [Integer] the largest_length
+      def largest_length
+        @executor.getLargestPoolSize
+      end
+
+      # The number of tasks that have been scheduled for execution on the pool since construction.
+      #
+      # @return [Integer] the scheduled_task_count
+      def scheduled_task_count
+        @executor.getTaskCount
+      end
+
+      # The number of tasks that have been completed by the pool since construction.
+      #
+      # @return [Integer] the completed_task_count
+      def completed_task_count
+        @executor.getCompletedTaskCount
+      end
+
+      # The number of seconds that a thread may be idle before being reclaimed.
+      #
+      # @return [Integer] the idletime
+      def idletime
+        @executor.getKeepAliveTime(java.util.concurrent.TimeUnit::SECONDS)
+      end
+
+      # The number of tasks in the queue awaiting execution.
+      #
+      # @return [Integer] the queue_length
+      def queue_length
+        @executor.getQueue.size
+      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
+      def remaining_capacity
+        @max_queue == 0 ? -1 : @executor.getQueue.remainingCapacity
+      end
+
+      # This method is deprecated and will be removed soon.
+      # This method is supost to return the threads status, but Java API doesn't
+      # provide a way to get the thread status. So we return an empty Array instead.
+      def status
+        warn '[DEPRECATED] `status` is deprecated and will be removed soon.'
+        warn "Calls to `status` return an empty Array. Java ThreadPoolExecutor does not provide thread's status."
+        []
+      end
+
+      # Is the thread pool running?
+      #
+      # @return [Boolean] `true` when running, `false` when shutting down or shutdown
+      def running?
+        super && !@executor.isTerminating
+      end
+    end
+  end
+end

data/lib/concurrent/executor/per_thread_executor.rb

@@ -0,0 +1,100 @@
+require 'concurrent/atomics'
+require 'concurrent/executor/executor'
+
+module Concurrent
+
+  # An executor service in which every operation spawns a new,
+  # independently operating thread.
+  #
+  # This is perhaps the most inefficient executor service in this
+  # library. It exists mainly for testing an debugging. Thread creation
+  # and management is expensive in Ruby and this executor performs no
+  # resource pooling. This can be very beneficial during testing and
+  # debugging because it decouples the using code from the underlying
+  # executor implementation. In production this executor will likely
+  # lead to suboptimal performance.
+  #
+  # @note Intended for use primarily in testing and debugging.
+  class PerThreadExecutor
+    include Executor
+
+    # Creates a new executor
+    def initialize
+      @running = Concurrent::AtomicBoolean.new(true)
+      @stopped = Concurrent::Event.new
+      @count = Concurrent::AtomicFixnum.new(0)
+    end
+
+    # @!macro executor_method_post
+    def self.post(*args)
+      raise ArgumentError.new('no block given') unless block_given?
+      Thread.new(*args) do
+        Thread.current.abort_on_exception = false
+        yield(*args)
+      end
+      true
+    end
+
+    # @!macro executor_method_left_shift
+    def self.<<(task)
+      post(&task)
+      self
+    end
+
+    # @!macro executor_method_post
+    def post(*args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      @count.increment
+      Thread.new(*args) do
+        Thread.current.abort_on_exception = false
+        begin
+          yield(*args)
+        ensure
+          @count.decrement
+          @stopped.set if @running.false? && @count.value == 0
+        end
+      end
+    end
+
+    # @!macro executor_method_left_shift
+    def <<(task)
+      post(&task)
+      self
+    end
+
+    # @!macro executor_method_running_question
+    def running?
+      @running.true?
+    end
+
+    # @!macro executor_method_shuttingdown_question
+    def shuttingdown?
+      @running.false? && ! @stopped.set?
+    end
+
+    # @!macro executor_method_shutdown_question
+    def shutdown?
+      @stopped.set?
+    end
+
+    # @!macro executor_method_shutdown
+    def shutdown
+      @running.make_false
+      @stopped.set if @count.value == 0
+      true
+    end
+
+    # @!macro executor_method_kill
+    def kill
+      @running.make_false
+      @stopped.set
+      true
+    end
+
+    # @!macro executor_method_wait_for_termination
+    def wait_for_termination(timeout = nil)
+      @stopped.wait(timeout)
+    end
+  end
+end

data/lib/concurrent/executor/ruby_cached_thread_pool.rb

@@ -0,0 +1,29 @@
+require 'concurrent/executor/ruby_thread_pool_executor'
+
+module Concurrent
+
+  # @!macro cached_thread_pool
+  class RubyCachedThreadPool < RubyThreadPoolExecutor
+
+    # Create a new thread pool.
+    #
+    # @param [Hash] opts the options defining pool behavior.
+    #   number of seconds a thread may be idle before it is reclaimed
+    #
+    # @raise [ArgumentError] if `overflow_policy` is not a known policy
+    def initialize(opts = {})
+      overflow_policy = opts.fetch(:overflow_policy, :abort)
+
+      raise ArgumentError.new("#{overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.include?(overflow_policy)
+
+      opts = opts.merge(
+        min_threads: 0,
+        max_threads: DEFAULT_MAX_POOL_SIZE,
+        overflow_policy: overflow_policy,
+        max_queue: DEFAULT_MAX_QUEUE_SIZE,
+        idletime: DEFAULT_THREAD_IDLETIMEOUT
+      )
+      super(opts)
+    end
+  end
+end

data/lib/concurrent/executor/ruby_fixed_thread_pool.rb

@@ -0,0 +1,32 @@
+require 'concurrent/executor/ruby_thread_pool_executor'
+
+module Concurrent
+
+  # @!macro fixed_thread_pool
+  class RubyFixedThreadPool < RubyThreadPoolExecutor
+
+    # Create a new thread pool.
+    #
+    # @param [Integer] num_threads the number of threads to allocate
+    # @param [Hash] opts the options defining pool behavior.
+    # @option opts [Symbol] :overflow_policy (`:abort`) the overflow policy
+    #
+    # @raise [ArgumentError] if `num_threads` is less than or equal to zero
+    # @raise [ArgumentError] if `overflow_policy` is not a known policy
+    def initialize(num_threads, opts = {})
+      overflow_policy = opts.fetch(:overflow_policy, :abort)
+
+      raise ArgumentError.new('number of threads must be greater than zero') if num_threads < 1
+      raise ArgumentError.new("#{overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.include?(overflow_policy)
+
+      opts = {
+        min_threads: num_threads,
+        max_threads: num_threads,
+        overflow_policy: overflow_policy,
+        max_queue: DEFAULT_MAX_QUEUE_SIZE,
+        idletime: DEFAULT_THREAD_IDLETIMEOUT,
+      }.merge(opts)
+      super(opts)
+    end
+  end
+end

data/lib/concurrent/executor/ruby_single_thread_executor.rb

@@ -0,0 +1,74 @@
+require_relative 'executor'
+
+module Concurrent
+
+  # @!macro single_thread_executor
+  class RubySingleThreadExecutor
+    include RubyExecutor
+    include SerialExecutor
+
+    # Create a new thread pool.
+    #
+    # @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
+    def initialize(opts = {})
+      @queue = Queue.new
+      @thread = nil
+      init_executor
+    end
+
+    protected
+
+    # @!visibility private
+    def execute(*args, &task)
+      supervise
+      @queue << [args, task]
+    end
+
+    # @!visibility private
+    def shutdown_execution
+      @queue << :stop
+      stopped_event.set unless alive?
+    end
+
+    # @!visibility private
+    def kill_execution
+      @queue.clear
+      @thread.kill if alive?
+    end
+
+    # @!visibility private
+    def alive?
+      @thread && @thread.alive?
+    end
+
+    # @!visibility private
+    def supervise
+      @thread = new_worker_thread unless alive?
+    end
+
+    # @!visibility private
+    def new_worker_thread
+      Thread.new do
+        Thread.current.abort_on_exception = false
+        work
+      end
+    end
+
+    # @!visibility private
+    def work
+      loop do
+        task = @queue.pop
+        break if task == :stop
+        begin
+          task.last.call(*task.first)
+        rescue => ex
+          # let it fail
+          log DEBUG, ex
+        end
+      end
+      stopped_event.set
+    end
+  end
+end