concurrent-ruby 0.9.2-java → 1.0.0-java

data/lib/concurrent/executor/immediate_executor.rb

@@ -1,5 +1,6 @@
 require 'concurrent/atomic/event'
-require 'concurrent/executor/executor_service'
+require 'concurrent/executor/abstract_executor_service'
+require 'concurrent/executor/serial_executor_service'
 
 module Concurrent
 
@@ -13,7 +14,7 @@ module Concurrent
   # during testing because it makes all operations deterministic.
   #
   # @note Intended for use primarily in testing and debugging.
-  class ImmediateExecutor
+  class ImmediateExecutor < AbstractExecutorService
     include SerialExecutorService
 
     # Creates a new executor

data/lib/concurrent/executor/java_executor_service.rb

@@ -0,0 +1,100 @@
+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
+        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
+
+      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
+
+      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
+    end
+  end
+end

data/lib/concurrent/executor/java_single_thread_executor.rb

@@ -1,11 +1,11 @@
 if Concurrent.on_jruby?
 
-  require 'concurrent/executor/executor_service'
+  require 'concurrent/executor/java_executor_service'
+  require 'concurrent/executor/serial_executor_service'
 
   module Concurrent
 
     # @!macro single_thread_executor
-    # @!macro thread_pool_options
     # @!macro abstract_executor_service_public_api
     # @!visibility private
     class JavaSingleThreadExecutor < JavaExecutorService
@@ -16,7 +16,7 @@ if Concurrent.on_jruby?
         super(opts)
       end
 
-      protected
+      private
       
       def ns_initialize(opts)
         @executor = java.util.concurrent.Executors.newSingleThreadExecutor

data/lib/concurrent/executor/java_thread_pool_executor.rb

@@ -1,6 +1,6 @@
 if Concurrent.on_jruby?
 
-  require 'concurrent/executor/executor_service'
+  require 'concurrent/executor/java_executor_service'
 
   module Concurrent
 
@@ -87,15 +87,14 @@ if Concurrent.on_jruby?
         super && !@executor.isTerminating
       end
 
-      protected
+      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, opts.fetch(:overflow_policy, :abort))
-        deprecated ' :overflow_policy is deprecated terminology, please use :fallback_policy instead' if opts.has_key?(:overflow_policy)
+        @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

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

@@ -1,78 +1,22 @@
-require 'concurrent/executor/executor_service'
+require 'concurrent/executor/ruby_thread_pool_executor'
 
 module Concurrent
 
   # @!macro single_thread_executor
-  # @!macro thread_pool_options
   # @!macro abstract_executor_service_public_api
   # @!visibility private
-  class RubySingleThreadExecutor < RubyExecutorService
-    include SerialExecutorService
+  class RubySingleThreadExecutor < RubyThreadPoolExecutor
 
     # @!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)
-      self.auto_terminate = opts.fetch(:auto_terminate, true)
-    end
-
-    # @!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
+      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

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -1,8 +1,7 @@
 require 'thread'
-
 require 'concurrent/atomic/event'
 require 'concurrent/concern/logging'
-require 'concurrent/executor/executor_service'
+require 'concurrent/executor/ruby_executor_service'
 require 'concurrent/utility/monotonic_time'
 
 module Concurrent
@@ -30,15 +29,6 @@ module Concurrent
     # @!macro thread_pool_executor_attr_reader_min_length
     attr_reader :min_length
 
-    # @!macro thread_pool_executor_attr_reader_largest_length
-    attr_reader :largest_length
-
-    # @!macro thread_pool_executor_attr_reader_scheduled_task_count
-    attr_reader :scheduled_task_count
-
-    # @!macro thread_pool_executor_attr_reader_completed_task_count
-    attr_reader :completed_task_count
-
     # @!macro thread_pool_executor_attr_reader_idletime
     attr_reader :idletime
 
@@ -50,6 +40,21 @@ module Concurrent
       super(opts)
     end
 
+    # @!macro thread_pool_executor_attr_reader_largest_length
+    def largest_length
+      synchronize { @largest_length }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_scheduled_task_count
+    def scheduled_task_count
+      synchronize { @scheduled_task_count }
+    end
+
+    # @!macro thread_pool_executor_attr_reader_completed_task_count
+    def completed_task_count
+      synchronize { @completed_task_count }
+    end
+
     # @!macro executor_service_method_can_overflow_question
     def can_overflow?
       synchronize { ns_limited_queue? }
@@ -96,7 +101,12 @@ module Concurrent
       synchronize { ns_worker_died worker }
     end
 
-    protected
+    # @!visibility private
+    def worker_task_completed
+      synchronize { @completed_task_count += 1 }
+    end
+
+    private
 
     # @!visibility private
     def ns_initialize(opts)
@@ -104,9 +114,8 @@ module Concurrent
       @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))
+      @fallback_policy = opts.fetch(:fallback_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
@@ -144,8 +153,6 @@ module Concurrent
       # raise unless @ready.empty? || @queue.empty? # assert
     end
 
-    alias_method :execute, :ns_execute
-
     # @!visibility private
     def ns_shutdown_execution
       if @pool.empty?
@@ -160,8 +167,6 @@ module Concurrent
       # raise unless @ready.empty? || @queue.empty? # assert
     end
 
-    alias_method :shutdown_execution, :ns_shutdown_execution
-
     # @!visibility private
     def ns_kill_execution
       # TODO log out unprocessed tasks in queue
@@ -171,8 +176,6 @@ module Concurrent
       @ready.clear
     end
 
-    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
     #
@@ -227,8 +230,7 @@ module Concurrent
     #
     # @!visibility private
     def ns_ready_worker(worker, success = true)
-      @completed_task_count += 1 if success
-      task_and_args         = @queue.shift
+      task_and_args = @queue.shift
       if task_and_args
         worker << task_and_args
       else
@@ -329,6 +331,7 @@ module Concurrent
 
       def run_task(pool, task, args)
         task.call(*args)
+        pool.worker_task_completed
       rescue => ex
         # let it fail
         log DEBUG, ex