concurrent-ruby 0.9.2 → 1.0.0.pre1

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,6 +1,7 @@
 if Concurrent.on_jruby?
 
-  require 'concurrent/executor/executor_service'
+  require 'concurrent/executor/java_executor_service'
+  require 'concurrent/executor/serial_executor_service'
 
   module Concurrent
 
@@ -16,7 +17,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,72 @@
+require 'concurrent/executor/abstract_executor_service'
+require 'concurrent/atomic/event'
+
+module Concurrent
+
+  # @!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?
+        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
+
+    attr_reader :stop_event, :stopped_event
+
+    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,4 +1,6 @@
-require 'concurrent/executor/executor_service'
+require 'thread'
+require 'concurrent/executor/ruby_executor_service'
+require 'concurrent/executor/serial_executor_service'
 
 module Concurrent
 
@@ -14,7 +16,7 @@ module Concurrent
       super
     end
 
-    protected
+    private
 
     def ns_initialize(opts)
       @queue = Queue.new
@@ -25,19 +27,19 @@ module Concurrent
     end
 
     # @!visibility private
-    def execute(*args, &task)
+    def ns_execute(*args, &task)
       supervise
       @queue << [args, task]
     end
 
     # @!visibility private
-    def shutdown_execution
+    def ns_shutdown_execution
       @queue << :stop
       stopped_event.set unless alive?
     end
 
     # @!visibility private
-    def kill_execution
+    def ns_kill_execution
       @queue.clear
       @thread.kill if alive?
     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
@@ -96,7 +95,7 @@ module Concurrent
       synchronize { ns_worker_died worker }
     end
 
-    protected
+    private
 
     # @!visibility private
     def ns_initialize(opts)
@@ -104,9 +103,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 +142,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 +156,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 +165,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
     #

data/lib/concurrent/executor/safe_task_executor.rb

@@ -1,4 +1,4 @@
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 

data/lib/concurrent/executor/serial_executor_service.rb

@@ -0,0 +1,34 @@
+require 'concurrent/executor/executor_service'
+
+module Concurrent
+
+  # 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
+end

data/lib/concurrent/executor/serialized_execution.rb

@@ -1,7 +1,6 @@
-require 'delegate'
-require 'concurrent/executor/executor_service'
+require 'concurrent/errors'
 require 'concurrent/concern/logging'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/object'
 
 module Concurrent
 
@@ -66,7 +65,7 @@ module Concurrent
       true
     end
 
-    protected
+    private
 
     def ns_initialize
       @being_executed = false
@@ -75,11 +74,11 @@ module Concurrent
 
     def call_job(job)
       did_it_run = begin
-        job.executor.post { work(job) }
-        true
-      rescue RejectedExecutionError => ex
-        false
-      end
+                     job.executor.post { work(job) }
+                     true
+                   rescue RejectedExecutionError => ex
+                     false
+                   end
 
       # TODO not the best idea to run it myself
       unless did_it_run
@@ -105,26 +104,4 @@ module Concurrent
       call_job job if job
     end
   end
-
-  # A wrapper/delegator for any `ExecutorService` that
-  # guarantees serialized execution of tasks.
-  #
-  # @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
-  # @see Concurrent::SerializedExecution
-  class SerializedExecutionDelegator < SimpleDelegator
-    include SerialExecutorService
-
-    def initialize(executor)
-      @executor   = executor
-      @serializer = SerializedExecution.new
-      super(executor)
-    end
-
-    # @!macro executor_service_method_post
-    def post(*args, &task)
-      Kernel.raise ArgumentError.new('no block given') unless block_given?
-      return false unless running?
-      @serializer.post(@executor, *args, &task)
-    end
-  end
 end

data/lib/concurrent/executor/serialized_execution_delegator.rb

@@ -0,0 +1,28 @@
+require 'delegate'
+require 'concurrent/executor/serial_executor_service'
+require 'concurrent/executor/serialized_execution'
+
+module Concurrent
+
+  # A wrapper/delegator for any `ExecutorService` that
+  # guarantees serialized execution of tasks.
+  #
+  # @see [SimpleDelegator](http://www.ruby-doc.org/stdlib-2.1.2/libdoc/delegate/rdoc/SimpleDelegator.html)
+  # @see Concurrent::SerializedExecution
+  class SerializedExecutionDelegator < SimpleDelegator
+    include SerialExecutorService
+
+    def initialize(executor)
+      @executor   = executor
+      @serializer = SerializedExecution.new
+      super(executor)
+    end
+
+    # @!macro executor_service_method_post
+    def post(*args, &task)
+      raise ArgumentError.new('no block given') unless block_given?
+      return false unless running?
+      @serializer.post(@executor, *args, &task)
+    end
+  end
+end