concurrent-ruby 0.6.0.pre.1 → 0.6.0.pre.2

data/lib/concurrent/channel/probe.rb

@@ -1,19 +0,0 @@
-module Concurrent
-  class Probe < IVar
-
-    def initialize(value = NO_VALUE, opts = {})
-      super(value, opts)
-    end
-
-    def set_unless_assigned(value)
-      mutex.synchronize do
-        return false if [:fulfilled, :rejected].include? @state
-
-        set_state(true, value, nil)
-        event.set
-        true
-      end
-
-    end
-  end
-end

data/lib/concurrent/count_down_latch.rb

@@ -1,60 +0,0 @@
-module Concurrent
-
-  # A synchronization object that allows one thread to wait on multiple other threads.
-  # The thread that will wait creates a +CountDownLatch+ and sets the initial value
-  # (normally equal to the number of other threads). The initiating thread passes the
-  # latch to the other threads then waits for the other threads by calling the +#wait+
-  # method. Each of the other threads calls +#count_down+ when done with its work.
-  # When the latch counter reaches zero the waiting thread is unblocked and continues
-  # with its work. A +CountDownLatch+ can be used only once. Its value cannot be reset.
-  class CountDownLatch
-
-    # Create a new +CountDownLatch+ with the initial +count+.
-    #
-    # @param [Fixnum] count the initial count
-    #
-    # @raise [ArgumentError] if +count+ is not an integer or is less than zero
-    def initialize(count)
-      unless count.is_a?(Fixnum) && count >= 0
-        raise ArgumentError.new('count must be in integer greater than or equal zero')
-      end
-      @mutex = Mutex.new
-      @condition = Condition.new
-      @count = count
-    end
-
-    # Block on the latch until the counter reaches zero or until +timeout+ is reached.
-    #
-    # @param [Fixnum] timeout the number of seconds to wait for the counter or +nil+
-    #   to block indefinitely
-    # @return [Boolean] +true+ if the +count+ reaches zero else false on +timeout+
-    def wait(timeout = nil)
-      @mutex.synchronize do
-
-        remaining = Condition::Result.new(timeout)
-        while @count > 0 && remaining.can_wait?
-          remaining = @condition.wait(@mutex, remaining.remaining_time)
-        end
-
-        @count == 0
-      end
-    end
-
-    # Signal the latch to decrement the counter. Will signal all blocked threads when
-    # the +count+ reaches zero.
-    def count_down
-      @mutex.synchronize do
-        @count -= 1 if @count > 0
-        @condition.broadcast if @count == 0
-      end
-    end
-
-    # The current value of the counter.
-    #
-    # @return [Fixnum] the current value of the counter
-    def count
-      @mutex.synchronize { @count }
-    end
-
-  end
-end

data/lib/concurrent/event.rb

@@ -1,80 +0,0 @@
-require 'thread'
-require 'concurrent/utilities'
-require 'concurrent/condition'
-
-module Concurrent
-
-  # Old school kernel-style event reminiscent of Win32 programming in C++.
-  #
-  # When an +Event+ is created it is in the +unset+ state. Threads can choose to
-  # +#wait+ on the event, blocking until released by another thread. When one
-  # thread wants to alert all blocking threads it calls the +#set+ method which
-  # will then wake up all listeners. Once an +Event+ has been set it remains set.
-  # New threads calling +#wait+ will return immediately. An +Event+ may be
-  # +#reset+ at any time once it has been set.
-  #
-  # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
-  class Event
-
-    # Creates a new +Event+ in the unset state. Threads calling +#wait+ on the
-    # +Event+ will block.
-    def initialize
-      @set = false
-      @mutex = Mutex.new
-      @condition = Condition.new
-    end
-
-    # Is the object in the set state?
-    #
-    # @return [Boolean] indicating whether or not the +Event+ has been set
-    def set?
-      @mutex.synchronize do
-        @set
-      end
-    end
-
-    # Trigger the event, setting the state to +set+ and releasing all threads
-    # waiting on the event. Has no effect if the +Event+ has already been set.
-    #
-    # @return [Boolean] should always return +true+
-    def set
-      @mutex.synchronize do
-        return true if @set
-        @set = true
-        @condition.broadcast
-      end
-
-      true
-    end
-
-    # Reset a previously set event back to the +unset+ state.
-    # Has no effect if the +Event+ has not yet been set.
-    #
-    # @return [Boolean] should always return +true+
-    def reset
-      @mutex.synchronize do
-        @set = false
-      end
-
-      true
-    end
-
-    # Wait a given number of seconds for the +Event+ to be set by another
-    # thread. Will wait forever when no +timeout+ value is given. Returns
-    # immediately if the +Event+ has already been set.
-    #
-    # @return [Boolean] true if the +Event+ was set before timeout else false
-    def wait(timeout = nil)
-      @mutex.synchronize do
-        return true if @set
-
-        remaining = Condition::Result.new(timeout)
-        while !@set && remaining.can_wait?
-          remaining = @condition.wait(@mutex, remaining.remaining_time)
-        end
-
-        @set
-      end
-    end
-  end
-end

data/lib/concurrent/java_cached_thread_pool.rb

@@ -1,45 +0,0 @@
-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/ruby_cached_thread_pool.rb

@@ -1,37 +0,0 @@
-require 'concurrent/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.
-    # @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
-    #
-    # @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
-    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)
-
-      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.include?(overflow_policy)
-
-      opts = opts.merge(
-        min_threads: 0,
-        max_threads: max_length,
-        num_threads: overflow_policy,
-        idletime: idletime
-      )
-      super(opts)
-    end
-  end
-end

data/lib/concurrent/ruby_thread_pool_executor.rb

@@ -1,268 +0,0 @@
-require 'thread'
-
-require 'concurrent/event'
-require 'concurrent/ruby_thread_pool_worker'
-
-module Concurrent
-
-  RejectedExecutionError = Class.new(StandardError) unless defined? RejectedExecutionError
-
-  # @!macro thread_pool_executor
-  class RubyThreadPoolExecutor
-
-    # The maximum number of threads that will be created in the pool
-    # (unless overridden during construction).
-    DEFAULT_MAX_POOL_SIZE = 2**15 # 32768
-
-    # 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, :discard, :caller_runs]
-
-    # The maximum number of threads that may be created in the pool.
-    attr_reader :max_length
-    attr_reader :min_length
-
-    attr_reader :largest_length
-
-    attr_reader :scheduled_task_count
-    attr_reader :completed_task_count
-
-    attr_reader :idletime
-
-    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.include?(@overflow_policy)
-
-      @state = :running
-      @pool = []
-      @terminator = Event.new
-      @queue = Queue.new
-      @mutex = Mutex.new
-      @scheduled_task_count = 0
-      @completed_task_count = 0
-      @largest_length = 0
-
-      @gc_interval = opts.fetch(:gc_interval, 1).to_i # undocumented
-      @last_gc_time = Time.now.to_f - [1.0, (@gc_interval * 2.0)].max
-    end
-
-    def length
-      @mutex.synchronize do
-        @state != :shutdown ? @pool.length : 0
-      end
-    end
-    alias_method :current_length, :length
-
-    def queue_length
-      @queue.length
-    end
-
-    def remaining_capacity
-      @mutex.synchronize { @max_queue == 0 ? -1 : @max_queue - @queue.length }
-    end
-
-    # Is the thread pool running?
-    #
-    # @return [Boolean] +true+ when running, +false+ when shutting down or shutdown
-    def running?
-      @mutex.synchronize { @state == :running }
-    end
-
-    # Returns an array with the status of each thread in the pool
-    #
-    # This method is deprecated and will be removed soon.
-    def status
-      warn '[DEPRECATED] `status` is deprecated and will be removed soon.'
-      @mutex.synchronize { @pool.collect { |worker| worker.status } }
-    end
-    
-    # Is the thread pool shutdown?
-    #
-    # @return [Boolean] +true+ when shutdown, +false+ when shutting down or running
-    def shutdown?
-      @mutex.synchronize { @state != :running }
-    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)
-      return @terminator.wait(timeout.to_i)
-    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, &task)
-      raise ArgumentError.new('no block given') unless block_given?
-      @mutex.synchronize do
-        break false unless @state == :running
-        return handle_overflow(*args, &task) if @max_queue != 0 && @queue.length >= @max_queue
-        @scheduled_task_count += 1
-        @queue << [args, task]
-        if Time.now.to_f - @gc_interval >= @last_gc_time
-          prune_pool
-          @last_gc_time = Time.now.to_f
-        end
-        grow_pool
-        true
-      end
-    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)
-      self.post(&task)
-      return self
-    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
-      @mutex.synchronize do
-        break unless @state == :running
-        @queue.clear
-        if @pool.empty?
-          @state = :shutdown
-          @terminator.set
-        else
-          @state = :shuttingdown
-          @pool.length.times{ @queue << :stop }
-        end
-      end
-    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
-      @mutex.synchronize do
-        break if @state == :shutdown
-        @queue.clear
-        @state = :shutdown
-        drain_pool
-        @terminator.set
-      end
-    end
-
-    # @!visibility private
-    def on_end_task # :nodoc:
-      @mutex.synchronize do
-        @completed_task_count += 1 #if success
-        break unless @state == :running
-      end
-    end
-
-    # @!visibility private
-    def on_worker_exit(worker) # :nodoc:
-      @mutex.synchronize do
-        @pool.delete(worker)
-        if @pool.empty? && @state != :running
-          @state = :shutdown
-          @terminator.set
-        end
-      end
-    end
-
-    protected
-
-    # @!visibility private
-    def handle_overflow(*args) # :nodoc:
-      case @overflow_policy
-      when :abort
-        raise RejectedExecutionError
-      when :discard
-        false
-      when :caller_runs
-        begin
-          yield(*args)
-        rescue
-          # let it fail
-        end
-        true
-      end
-    end
-
-    # @!visibility private
-    def prune_pool # :nodoc:
-      @pool.delete_if do |worker|
-        worker.dead? ||
-          (@idletime == 0 ? false : Time.now.to_f - @idletime > worker.last_activity)
-      end
-    end
-
-    # @!visibility private
-    def grow_pool # :nodoc:
-      if @min_length > @pool.length
-        additional = @min_length - @pool.length
-      elsif @pool.length < @max_length && ! @queue.empty?
-        # NOTE: does not take into account idle threads
-        additional = 1
-      else
-        additional = 0
-      end
-      additional.times do
-        break if @pool.length >= @max_length
-        @pool << create_worker_thread
-      end
-      @largest_length = [@largest_length, @pool.length].max
-    end
-
-    # @!visibility private
-    def drain_pool # :nodoc:
-      @pool.each {|worker| worker.kill }
-      @pool.clear
-    end
-
-    # @!visibility private
-    def create_worker_thread # :nodoc:
-      wrkr = RubyThreadPoolWorker.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
-  end
-end