concurrent-ruby 0.5.0 → 0.6.0.pre.1

data/lib/concurrent/exchanger.rb

@@ -0,0 +1,31 @@
+module Concurrent
+  class Exchanger
+
+    EMPTY = Object.new
+
+    def initialize(opts = {})
+      @first = MVar.new(EMPTY, opts)
+      @second = MVar.new(MVar::EMPTY, opts)
+    end
+
+    def exchange(value, timeout = nil)
+      first = @first.take(timeout)
+      if first == MVar::TIMEOUT
+        nil
+      elsif first == EMPTY
+        @first.put value
+        second = @second.take timeout
+        if second == MVar::TIMEOUT
+          nil
+        else
+          second
+        end
+      else
+        @first.put EMPTY
+        @second.put value
+        first
+      end
+    end
+
+  end
+end

data/lib/concurrent/fixed_thread_pool.rb

@@ -1,128 +1,34 @@
-require 'thread'
-
-require 'concurrent/event'
-require 'concurrent/fixed_thread_pool/worker'
+require 'concurrent/ruby_fixed_thread_pool'
 
 module Concurrent
 
-  class FixedThreadPool
-
-    MIN_POOL_SIZE = 1
-    MAX_POOL_SIZE = 256
-
-    attr_accessor :max_threads
-
-    def initialize(size, opts = {})
-      @max_threads = size || MAX_POOL_SIZE
-      if @max_threads < MIN_POOL_SIZE || @max_threads > MAX_POOL_SIZE
-        raise ArgumentError.new("size must be from #{MIN_POOL_SIZE} to #{MAX_POOL_SIZE}")
-      end
-
-      @state = :running
-      @pool = []
-      @terminator = Event.new
-      @queue = Queue.new
-      @mutex = Mutex.new
-    end
-
-    def running?
-      return @state == :running
-    end
-
-    def wait_for_termination(timeout = nil)
-      return @terminator.wait(timeout)
-    end
-
-    def post(*args, &block)
-      raise ArgumentError.new('no block given') if block.nil?
-      @mutex.synchronize do
-        break false unless @state == :running
-        @queue << [args, block]
-        clean_pool
-        fill_pool
-        true
-      end
-    end
-
-    def <<(block)
-      self.post(&block)
-      return self
-    end
-
-    def shutdown
-      @mutex.synchronize do
-        break unless @state == :running
-        if @pool.empty?
-          @state = :shutdown
-          @terminator.set
-        else
-          @state = :shuttingdown
-          @pool.length.times{ @queue << :stop }
-        end
-      end
-    end
-
-    def kill
-      @mutex.synchronize do
-        break if @state == :shutdown
-        @state = :shutdown
-        @queue.clear
-        drain_pool
-        @terminator.set
-      end
-    end
-
-    def length
-      @mutex.synchronize do
-        @state == :running ? @pool.length : 0
-      end
-    end
-
-    def create_worker_thread
-      wrkr = Worker.new(@queue, self)
-      Thread.new(wrkr, self) do |worker, parent|
-        Thread.current.abort_on_exception = false
-        worker.run
-        parent.on_worker_exit(worker)
-      end
-      return wrkr
-    end
-
-    def fill_pool
-      return unless @state == :running
-      while @pool.length < @max_threads
-        @pool << create_worker_thread
-      end
-    end
-
-    def clean_pool
-      @pool.reject! {|worker| worker.dead? } 
-    end
-
-    def drain_pool
-      @pool.each {|worker| worker.kill }
-      @pool.clear
-    end
-
-    def on_start_task(worker)
-    end
-
-    def on_end_task(worker)
-      @mutex.synchronize do
-        break unless @state == :running
-        clean_pool
-        fill_pool
-      end
-    end
-
-    def on_worker_exit(worker)
-      @mutex.synchronize do
-        @pool.delete(worker)
-        if @pool.empty? && @state != :running
-          @state = :shutdown
-          @terminator.set
-        end
-      end
+  if RUBY_PLATFORM == 'java'
+    require 'concurrent/java_fixed_thread_pool'
+    # @!macro [attach] fixed_thread_pool
+    #
+    #   A thread pool with a set number of threads. The number of threads in the pool
+    #   is set on construction and remains constant. When all threads are busy new
+    #   tasks +#post+ to the thread pool are enqueued until a thread becomes available.
+    #   Should a thread crash for any reason the thread will immediately be removed
+    #   from the pool and replaced.
+    #
+    #   The API and behavior of this class are based on Java's +FixedThreadPool+
+    #
+    #   @note When running on the JVM (JRuby) this class will inherit from +JavaFixedThreadPool+.
+    #     On all other platforms it will inherit from +RubyFixedThreadPool+.
+    #
+    #   @see Concurrent::RubyFixedThreadPool
+    #   @see Concurrent::JavaFixedThreadPool
+    #
+    #   @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
+    #   @see http://stackoverflow.com/questions/17957382/fixedthreadpool-vs-fixedthreadpool-the-lesser-of-two-evils
+    class FixedThreadPool < JavaFixedThreadPool
+    end
+  else
+    # @!macro fixed_thread_pool
+    class FixedThreadPool < RubyFixedThreadPool
     end
   end
 end

data/lib/concurrent/future.rb

@@ -1,7 +1,7 @@
 require 'thread'
 
+require 'concurrent/configuration'
 require 'concurrent/obligation'
-require 'concurrent/global_thread_pool'
 require 'concurrent/safe_task_executor'
 
 module Concurrent
@@ -41,13 +41,18 @@ module Concurrent
   # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/Future.html java.util.concurrent.Future
   class Future < IVar
     include Obligation
-    include UsesGlobalThreadPool
+    include OptionsParser
 
     # Create a new +Future+ in the +:unscheduled+ state.
     #
     # @yield the asynchronous operation to perform
     #
     # @param [Hash] opts the options to create a message with
+    # @option opts [Boolean] :operation (false) when +true+ will execute the future on the global
+    #   operation pool (for long-running operations), when +false+ will execute the future on the
+    #   global task pool (for short-running tasks)
+    # @option opts [object] :executor when provided will run all operations on
+    #   this executor rather than the global thread pool (overrides :operation)
     # @option opts [String] :dup_on_deref (false) call +#dup+ before returning the data
     # @option opts [String] :freeze_on_deref (false) call +#freeze+ before returning the data
     # @option opts [String] :copy_on_deref (nil) call the given +Proc+ passing the internal value and
@@ -59,6 +64,7 @@ module Concurrent
       super(IVar::NO_VALUE, opts)
       @state = :unscheduled
       @task = block
+      @executor = get_executor_from(opts)
     end
 
     # Execute an +:unscheduled+ +Future+. Immediately sets the state to +:pending+ and
@@ -80,7 +86,7 @@ module Concurrent
     # @since 0.5.0
     def execute
       if compare_and_set_state(:pending, :unscheduled)
-        Future.thread_pool.post { work }
+        @executor.post{ work }
         self
       end
     end
@@ -105,7 +111,7 @@ module Concurrent
     #
     # @since 0.5.0
     def self.execute(opts = {}, &block)
-      return Future.new(opts, &block).execute
+      Future.new(opts, &block).execute
     end
 
     protected :set, :fail, :complete
@@ -117,6 +123,5 @@ module Concurrent
       success, val, reason = SafeTaskExecutor.new(@task).execute
       complete(success, val, reason)
     end
-    
   end
 end

data/lib/concurrent/immediate_executor.rb

@@ -2,13 +2,14 @@ module Concurrent
   class ImmediateExecutor
 
     def post(*args, &block)
+      raise ArgumentError.new('no block given') unless block_given?
       block.call(*args)
+      return true
     end
 
     def <<(block)
       post(&block)
       self
     end
-
   end
-end
+end

data/lib/concurrent/ivar.rb

@@ -60,7 +60,7 @@ module Concurrent
       complete(true, value, nil)
     end
 
-    def fail(reason = nil)
+    def fail(reason = StandardError.new)
       complete(false, nil, reason)
     end
 
@@ -73,6 +73,7 @@ module Concurrent
 
       time = Time.now
       @observers.notify_and_delete_observers{ [time, self.value, reason] }
+      self
     end
   end
 end

data/lib/concurrent/java_cached_thread_pool.rb

@@ -0,0 +1,45 @@
+if RUBY_PLATFORM == 'java'
+
+  require 'concurrent/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 [Integer] :max_threads (+DEFAULT_MAX_POOL_SIZE+) maximum number
+      #   of threads which may be created in the pool
+      # @option opts [Integer] :idletime (+DEFAULT_THREAD_IDLETIMEOUT+) maximum
+      #   number of seconds a thread may be idle before it is reclaimed
+      # @option opts [Symbol] :overflow_policy (+:abort+) the overflow policy
+      #
+      # @raise [ArgumentError] if +max_threads+ is less than or equal to zero
+      # @raise [ArgumentError] if +idletime+ 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#newCachedThreadPool--
+      def initialize(opts = {})
+        max_length = opts.fetch(:max_threads, DEFAULT_MAX_POOL_SIZE).to_i
+        idletime = opts.fetch(:idletime, DEFAULT_THREAD_IDLETIMEOUT).to_i
+        @overflow_policy = opts.fetch(:overflow_policy, :abort)
+        @max_queue = 0
+
+        raise ArgumentError.new('idletime must be greater than zero') if idletime <= 0
+        raise ArgumentError.new('max_threads must be greater than zero') if max_length <= 0
+        raise ArgumentError.new("#{@overflow_policy} is not a valid overflow policy") unless OVERFLOW_POLICIES.keys.include?(@overflow_policy)
+
+        @executor = java.util.concurrent.ThreadPoolExecutor.new(
+          @max_queue, max_length,
+          idletime, java.util.concurrent.TimeUnit::SECONDS,
+          java.util.concurrent.SynchronousQueue.new,
+          OVERFLOW_POLICIES[@overflow_policy].new)
+
+        # without this the process may fail to exit
+        at_exit { self.kill }
+      end
+    end
+  end
+end

data/lib/concurrent/java_fixed_thread_pool.rb

@@ -0,0 +1,37 @@
+if RUBY_PLATFORM == 'java'
+
+  require 'concurrent/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 = {})
+        @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.ThreadPoolExecutor.new(
+          num_threads, num_threads,
+          @max_queue, java.util.concurrent.TimeUnit::SECONDS,
+          java.util.concurrent.LinkedBlockingQueue.new,
+          OVERFLOW_POLICIES[@overflow_policy].new)
+
+        # without this the process may fail to exit
+        at_exit { self.kill }
+      end
+    end
+  end
+end

data/lib/concurrent/java_thread_pool_executor.rb

@@ -0,0 +1,194 @@
+if RUBY_PLATFORM == 'java'
+
+  module Concurrent
+
+    RejectedExecutionError = Class.new(StandardError) unless defined? RejectedExecutionError
+
+    # @!macro thread_pool_executor
+    class JavaThreadPoolExecutor
+
+      # The maximum number of threads that will be created in the pool
+      # (unless overridden during construction).
+      DEFAULT_MAX_POOL_SIZE = java.lang.Integer::MAX_VALUE # 2147483647
+
+      # The minimum number of threads that will be created in the pool
+      # (unless overridden during construction).
+      DEFAULT_MIN_POOL_SIZE = 0
+
+      DEFAULT_MAX_QUEUE_SIZE = 0
+
+      # The maximum number of seconds a thread in the pool may remain idle before
+      # being reclaimed (unless overridden during construction).
+      DEFAULT_THREAD_IDLETIMEOUT = 60
+
+      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
+
+      attr_reader :max_queue
+
+      attr_reader :overflow_policy
+
+      # Create a new thread pool.
+      #
+      # @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("#{@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)
+
+        # without this the process may fail to exit
+        at_exit { self.kill }
+      end
+
+      def min_length
+        @executor.getCorePoolSize
+      end
+
+      def max_length
+        @executor.getMaximumPoolSize
+      end
+
+      def length
+        @executor.getPoolSize
+      end
+      alias_method :current_length, :length
+
+      def largest_length
+        @executor.getLargestPoolSize
+      end
+
+      def scheduled_task_count
+        @executor.getTaskCount
+      end
+
+      def completed_task_count
+        @executor.getCompletedTaskCount
+      end
+
+      def idletime
+        @executor.getKeepAliveTime(java.util.concurrent.TimeUnit::SECONDS)
+      end
+
+      def queue_length
+        @executor.getQueue.size
+      end
+
+      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?
+        ! (@executor.isShutdown || @executor.isTerminated || @executor.isTerminating)
+      end
+
+      # Is the thread pool shutdown?
+      #
+      # @return [Boolean] +true+ when shutdown, +false+ when shutting down or running
+      def shutdown?
+        @executor.isShutdown
+      end
+
+      # Block until thread pool shutdown is complete or until +timeout+ seconds have
+      # passed.
+      #
+      # @note Does not initiate shutdown or termination. Either +shutdown+ or +kill+
+      #   must be called before this method (or on another thread).
+      #
+      # @param [Integer] timeout the maximum number of seconds to wait for shutdown to complete
+      #
+      # @return [Boolean] +true+ if shutdown complete or false on +timeout+
+      def wait_for_termination(timeout)
+        @executor.awaitTermination(timeout.to_i, java.util.concurrent.TimeUnit::SECONDS)
+      end
+
+      # Submit a task to the thread pool for asynchronous processing.
+      #
+      # @param [Array] args zero or more arguments to be passed to the task
+      #
+      # @yield the asynchronous task to perform
+      #
+      # @return [Boolean] +true+ if the task is queued, +false+ if the thread pool
+      #   is not running
+      #
+      # @raise [ArgumentError] if no task is given
+      def post(*args)
+        raise ArgumentError.new('no block given') unless block_given?
+        if running?
+          @executor.submit{ yield(*args) }
+          true
+        else
+          false
+        end
+      rescue Java::JavaUtilConcurrent::RejectedExecutionException => ex
+        raise RejectedExecutionError
+      end
+
+      # Submit a task to the thread pool for asynchronous processing.
+      #
+      # @param [Proc] task the asynchronous task to perform
+      #
+      # @return [self] returns itself
+      def <<(task)
+        @executor.submit(&task)
+      rescue Java::JavaUtilConcurrent::RejectedExecutionException => ex
+        raise RejectedExecutionError
+      end
+
+      # Begin an orderly shutdown. Tasks already in the queue will be executed,
+      # but no new tasks will be accepted. Has no additional effect if the
+      # thread pool is not running.
+      def shutdown
+        @executor.shutdown
+        @executor.getQueue.clear
+        return nil
+      end
+
+      # Begin an immediate shutdown. In-progress tasks will be allowed to
+      # complete but enqueued tasks will be dismissed and no new tasks
+      # will be accepted. Has no additional effect if the thread pool is
+      # not running.
+      def kill
+        @executor.shutdownNow
+        @executor.getQueue.clear
+        return nil
+      end
+    end
+  end
+end