concurrent-ruby 0.9.2 → 1.0.0.pre1

data/lib/concurrent/executor/simple_executor_service.rb

@@ -89,7 +89,7 @@ module Concurrent
       @stopped.wait(timeout)
     end
 
-    protected
+    private
 
     def ns_initialize
       @running = Concurrent::AtomicBoolean.new(true)
@@ -97,13 +97,4 @@ module Concurrent
       @count = Concurrent::AtomicFixnum.new(0)
     end
   end
-
-  # @deprecated
-  class PerThreadExecutor < SimpleExecutorService
-
-    def initialize
-      deprecated 'use SimpleExecutorService instead'
-      super
-    end
-  end
 end

data/lib/concurrent/executor/timer_set.rb

@@ -1,7 +1,6 @@
 require 'concurrent/scheduled_task'
 require 'concurrent/atomic/event'
-require 'concurrent/collection/priority_queue'
-require 'concurrent/concern/deprecation'
+require 'concurrent/collection/non_concurrent_priority_queue'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/single_thread_executor'
 
@@ -16,7 +15,6 @@ module Concurrent
   #
   # @!macro monotonic_clock_warning
   class TimerSet < RubyExecutorService
-    extend Concern::Deprecation
 
     # Create a new set of timed tasks.
     #
@@ -45,8 +43,6 @@ module Concurrent
     #
     # @raise [ArgumentError] if the intended execution time is not in the future.
     # @raise [ArgumentError] if no block is given.
-    #
-    # @!macro deprecated_scheduling_by_clock_time
     def post(delay, *args, &task)
       raise ArgumentError.new('no block given') unless block_given?
       return false unless running?
@@ -69,14 +65,14 @@ module Concurrent
 
     private :<<
 
-    protected
+    private
 
     # Initialize the object.
     #
     # @param [Hash] opts the options to create the object with.
     # @!visibility private
     def ns_initialize(opts)
-      @queue          = Collection::PriorityQueue.new(order: :min)
+      @queue          = Collection::NonConcurrentPriorityQueue.new(order: :min)
       @task_executor  = Executor.executor_from_options(opts) || Concurrent.global_io_executor
       @timer_executor = SingleThreadExecutor.new
       @condition      = Event.new
@@ -122,7 +118,7 @@ module Concurrent
     # `ExecutorServic` callback called during shutdown.
     #
     # @!visibility private
-    def shutdown_execution
+    def ns_shutdown_execution
       @queue.clear
       @timer_executor.kill
       stopped_event.set

data/lib/concurrent/executors.rb

@@ -1,10 +1,21 @@
+require 'concurrent/executor/abstract_executor_service'
 require 'concurrent/executor/cached_thread_pool'
+require 'concurrent/executor/executor'
+require 'concurrent/executor/executor_service'
 require 'concurrent/executor/fixed_thread_pool'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/indirect_immediate_executor'
+require 'concurrent/executor/java_executor_service'
+require 'concurrent/executor/java_single_thread_executor'
+require 'concurrent/executor/java_thread_pool_executor'
+require 'concurrent/executor/ruby_executor_service'
+require 'concurrent/executor/ruby_single_thread_executor'
+require 'concurrent/executor/ruby_thread_pool_executor'
+require 'concurrent/executor/cached_thread_pool'
 require 'concurrent/executor/safe_task_executor'
-require 'concurrent/executor/simple_executor_service'
+require 'concurrent/executor/serial_executor_service'
+require 'concurrent/executor/serialized_execution'
+require 'concurrent/executor/serialized_execution_delegator'
 require 'concurrent/executor/single_thread_executor'
 require 'concurrent/executor/thread_pool_executor'
 require 'concurrent/executor/timer_set'
-require 'concurrent/executor/serialized_execution'

data/lib/concurrent/future.rb

@@ -27,7 +27,7 @@ module Concurrent
     # @raise [ArgumentError] if no block is given
     def initialize(opts = {}, &block)
       raise ArgumentError.new('no block given') unless block_given?
-      super(IVar::NO_VALUE, opts.merge(__task_from_block__: block), &nil)
+      super(NULL, opts.merge(__task_from_block__: block), &nil)
     end
 
     # Execute an `:unscheduled` `Future`. Immediately sets the state to `:pending` and
@@ -74,7 +74,7 @@ module Concurrent
     end
 
     # @!macro ivar_set_method
-    def set(value = IVar::NO_VALUE, &block)
+    def set(value = NULL, &block)
       check_for_block_or_value!(block_given?, value)
       synchronize do
         if @state != :unscheduled

data/lib/concurrent/hash.rb

@@ -0,0 +1,35 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+
+module Concurrent
+  if Concurrent.on_cruby?
+
+    # @!macro [attach] concurrent_hash
+    #
+    #   A thread-safe subclass of Hash. This version locks against the object
+    #   itself for every method call, ensuring only one thread can be reading
+    #   or writing at a time. This includes iteration methods like `#each`.
+    #
+    #   @see http://ruby-doc.org/core-2.2.0/Hash.html Ruby standard library `Hash`
+    class Hash < ::Hash;
+    end
+
+  elsif Concurrent.on_jruby?
+    require 'jruby/synchronized'
+
+    # @!macro concurrent_hash
+    class Hash < ::Hash
+      include JRuby::Synchronized
+    end
+
+  elsif Concurrent.on_rbx?
+    require 'monitor'
+
+    # @!macro concurrent_hash
+    class Hash < ::Hash
+    end
+
+    ThreadSafe::Util.make_synchronized_on_rbx Hash
+
+  end
+end

data/lib/concurrent/ivar.rb

@@ -1,5 +1,3 @@
-require 'thread'
-
 require 'concurrent/errors'
 require 'concurrent/collection/copy_on_write_observer_set'
 require 'concurrent/concern/obligation'
@@ -49,9 +47,6 @@ module Concurrent
     include Concern::Obligation
     include Concern::Observable
 
-    # @!visibility private
-    NO_VALUE = Object.new # :nodoc:
-
     # Create a new `IVar` in the `:pending` state with the (optional) initial value.
     #
     # @param [Object] value the initial value
@@ -62,8 +57,8 @@ module Concurrent
     #   returning the data
     # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing
     #   the internal value and returning the value returned from the proc
-    def initialize(value = NO_VALUE, opts = {}, &block)
-      if value != NO_VALUE && block_given?
+    def initialize(value = NULL, opts = {}, &block)
+      if value != NULL && block_given?
         raise ArgumentError.new('provide only a value or a block')
       end
       super(&nil)
@@ -104,16 +99,16 @@ module Concurrent
 
     # @!macro [attach] ivar_set_method
     #   Set the `IVar` to a value and wake or notify all threads waiting on it.
-    #  
+    #
     #   @!macro [attach] ivar_set_parameters_and_exceptions
     #     @param [Object] value the value to store in the `IVar`
     #     @yield A block operation to use for setting the value
     #     @raise [ArgumentError] if both a value and a block are given
     #     @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
     #       been set or otherwise completed
-    #  
+    #
     #   @return [IVar] self
-    def set(value = NO_VALUE)
+    def set(value = NULL)
       check_for_block_or_value!(block_given?, value)
       raise MultipleAssignmentError unless compare_and_set_state(:processing, :pending)
 
@@ -130,7 +125,7 @@ module Concurrent
 
     # @!macro [attach] ivar_fail_method
     #   Set the `IVar` to failed due to some error and wake or notify all threads waiting on it.
-    #  
+    #
     #   @param [Object] reason for the failure
     #   @raise [Concurrent::MultipleAssignmentError] if the `IVar` has already
     #     been set or otherwise completed
@@ -145,7 +140,7 @@ module Concurrent
     # @!macro ivar_set_parameters_and_exceptions
     #
     # @return [Boolean] true if the value was set else false
-    def try_set(value = NO_VALUE, &block)
+    def try_set(value = NULL, &block)
       set(value, &block)
       true
     rescue MultipleAssignmentError
@@ -161,7 +156,7 @@ module Concurrent
       self.observers = Collection::CopyOnWriteObserverSet.new
       set_deref_options(opts)
 
-      if value == NO_VALUE
+      if value == NULL
         @state = :pending
       else
         ns_complete_without_notification(true, value, nil)
@@ -204,7 +199,7 @@ module Concurrent
 
     # @!visibility private
     def check_for_block_or_value!(block_given, value) # :nodoc:
-      if (block_given && value != NO_VALUE) || (! block_given && value == NO_VALUE)
+      if (block_given && value != NULL) || (! block_given && value == NULL)
         raise ArgumentError.new('must set with either a value or a block')
       end
     end

data/lib/concurrent/map.rb

@@ -0,0 +1,178 @@
+require 'thread'
+
+module Concurrent
+  # @!visibility private
+  module Collection
+
+    # @!visibility private
+    MapImplementation = if defined?(RUBY_ENGINE)
+                   case RUBY_ENGINE
+                   when 'jruby'
+                     # noinspection RubyResolve
+                     JRubyMapBackend
+                   when 'ruby'
+                     require 'concurrent/collection/map/mri_map_backend'
+                     MriMapBackend
+                   when 'rbx'
+                     require 'concurrent/collection/map/atomic_reference_map_backend'
+                     AtomicReferenceMapBackend
+                   else
+                     warn 'Concurrent::Map: unsupported Ruby engine, using a fully synchronized Concurrent::Map implementation' if $VERBOSE
+                     require 'concurrent/collection/map/synchronized_map_backend'
+                     SynchronizedMapBackend
+                   end
+                 else
+                   MriMapBackend
+                 end
+  end
+
+  # `Concurrent::Map` is a hash-like object and should have much better performance
+  # characteristics, especially under high concurrency, than `Concurrent::Hash`.
+  # However, `Concurrent::Map `is not strictly semantically equivalent to a ruby `Hash`
+  # -- for instance, it does not necessarily retain ordering by insertion time as `Hash`
+  # does. For most uses it should do fine though, and we recommend you consider
+  # `Concurrent::Map` instead of `Concurrent::Hash` for your concurrency-safe hash needs.
+  #
+  # > require 'concurrent'
+  # >
+  # > map = Concurrent::Map.new
+
+  class Map < Collection::MapImplementation
+    def initialize(options = nil, &block)
+      if options.kind_of?(::Hash)
+        validate_options_hash!(options)
+      else
+        options = nil
+      end
+
+      super(options)
+      @default_proc = block
+    end
+
+    def [](key)
+      if value = super # non-falsy value is an existing mapping, return it right away
+        value
+        # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
+        # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
+        # would be returned)
+        # note: nil == value check is not technically necessary
+      elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))
+        @default_proc.call(self, key)
+      else
+        value
+      end
+    end
+
+    alias_method :get, :[]
+    alias_method :put, :[]=
+
+    def fetch(key, default_value = NULL)
+      if NULL != (value = get_or_default(key, NULL))
+        value
+      elsif block_given?
+        yield key
+      elsif NULL != default_value
+        default_value
+      else
+        raise_fetch_no_key
+      end
+    end
+
+    def fetch_or_store(key, default_value = NULL)
+      fetch(key) do
+        put(key, block_given? ? yield(key) : (NULL == default_value ? raise_fetch_no_key : default_value))
+      end
+    end
+
+    def put_if_absent(key, value)
+      computed = false
+      result = compute_if_absent(key) do
+        computed = true
+        value
+      end
+      computed ? nil : result
+    end unless method_defined?(:put_if_absent)
+
+    def value?(value)
+      each_value do |v|
+        return true if value.equal?(v)
+      end
+      false
+    end unless method_defined?(:value?)
+
+    def keys
+      arr = []
+      each_pair {|k, v| arr << k}
+      arr
+    end unless method_defined?(:keys)
+
+    def values
+      arr = []
+      each_pair {|k, v| arr << v}
+      arr
+    end unless method_defined?(:values)
+
+    def each_key
+      each_pair {|k, v| yield k}
+    end unless method_defined?(:each_key)
+
+    def each_value
+      each_pair {|k, v| yield v}
+    end unless method_defined?(:each_value)
+
+    def key(value)
+      each_pair {|k, v| return k if v == value}
+      nil
+    end unless method_defined?(:key)
+    alias_method :index, :key if RUBY_VERSION < '1.9'
+
+    def empty?
+      each_pair {|k, v| return false}
+      true
+    end unless method_defined?(:empty?)
+
+    def size
+      count = 0
+      each_pair {|k, v| count += 1}
+      count
+    end unless method_defined?(:size)
+
+    def marshal_dump
+      raise TypeError, "can't dump hash with default proc" if @default_proc
+      h = {}
+      each_pair {|k, v| h[k] = v}
+      h
+    end
+
+    def marshal_load(hash)
+      initialize
+      populate_from(hash)
+    end
+
+    undef :freeze
+
+    private
+    def raise_fetch_no_key
+      raise KeyError, 'key not found'
+    end
+
+    def initialize_copy(other)
+      super
+      populate_from(other)
+    end
+
+    def populate_from(hash)
+      hash.each_pair {|k, v| self[k] = v}
+      self
+    end
+
+    def validate_options_hash!(options)
+      if (initial_capacity = options[:initial_capacity]) && (!initial_capacity.kind_of?(Fixnum) || initial_capacity < 0)
+        raise ArgumentError, ":initial_capacity must be a positive Fixnum"
+      end
+      if (load_factor = options[:load_factor]) && (!load_factor.kind_of?(Numeric) || load_factor <= 0 || load_factor > 1)
+        raise ArgumentError, ":load_factor must be a number between 0 and 1"
+      end
+    end
+  end
+end

data/lib/concurrent/promise.rb

@@ -205,7 +205,7 @@ module Concurrent
     # @see http://promises-aplus.github.io/promises-spec/
     def initialize(opts = {}, &block)
       opts.delete_if { |k, v| v.nil? }
-      super(IVar::NO_VALUE, opts.merge(__promise_body_from_block__: block), &nil)
+      super(NULL, opts.merge(__promise_body_from_block__: block), &nil)
     end
 
     # Create a new `Promise` and fulfill it immediately.
@@ -254,7 +254,7 @@ module Concurrent
     # @!macro ivar_set_method
     #
     # @raise [Concurrent::PromiseExecutionError] if not the root promise
-    def set(value = IVar::NO_VALUE, &block)
+    def set(value = NULL, &block)
       raise PromiseExecutionError.new('supported only on root promise') unless root?
       check_for_block_or_value!(block_given?, value)
       synchronize do

data/lib/concurrent/scheduled_task.rb

@@ -1,12 +1,11 @@
 require 'concurrent/errors'
+require 'concurrent/configuration'
 require 'concurrent/ivar'
 require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/executor/executor'
 require 'concurrent/utility/monotonic_time'
-require 'concurrent/concern/deprecation'
 
 module Concurrent
-  include Concern::Deprecation
 
   # `ScheduledTask` is a close relative of `Concurrent::Future` but with one
   # important difference: A `Future` is set to execute as soon as possible
@@ -161,21 +160,17 @@ module Concurrent
     #
     # @raise [ArgumentError] When no block is given
     # @raise [ArgumentError] When given a time that is in the past
-    #
-    # @!macro [attach] deprecated_scheduling_by_clock_time
-    #
-    #   @note Scheduling is now based on a monotonic clock. This makes the timer much
-    #     more accurate, but only when scheduling based on a delay interval.
-    #     Scheduling a task based on a clock time is deprecated. It will still work
-    #     but will not be supported in the 1.0 release.
     def initialize(delay, opts = {}, &task)
       raise ArgumentError.new('no block given') unless block_given?
-      super(IVar::NO_VALUE, opts, &nil)
+      raise ArgumentError.new('seconds must be greater than zero') if delay.to_f < 0.0
+
+      super(NULL, opts, &nil)
+
       synchronize do
-        @delay = calculate_delay!(delay) # may raise exception
         ns_set_state(:unscheduled)
         @parent = opts.fetch(:timer_set, Concurrent.global_timer_set)
         @args = get_arguments_from(opts)
+        @delay = delay.to_f
         @task = task
         @time = nil
         @executor = Executor.executor_from_options(opts) || Concurrent.global_io_executor
@@ -190,16 +185,6 @@ module Concurrent
       synchronize { @delay }
     end
 
-    # The `delay` value given at instanciation.
-    #
-    # @return [Float] the initial delay.
-    #
-    # @deprecated use {#initial_delay} instead
-    def delay
-      deprecated_method 'delay', 'initial_delay'
-      initial_delay
-    end
-
     # The monotonic time at which the the task is scheduled to be executed.
     #
     # @return [Float] the schedule time or nil if `unscheduled`
@@ -228,16 +213,6 @@ module Concurrent
       synchronize { ns_check_state?(:processing) }
     end
 
-    # In the task execution in progress?
-    #
-    # @return [Boolean] true if the task is in the given state else false
-    #
-    # @deprecated Use {#processing?} instead.
-    def in_progress?
-      deprecated_method 'in_progress?', 'processing?'
-      processing?
-    end
-
     # Cancel this task and prevent it from executing. A task can only be
     # cancelled if it is pending or unscheduled.
     #
@@ -253,17 +228,6 @@ module Concurrent
       end
     end
 
-    # Cancel this task and prevent it from executing. A task can only be
-    # cancelled if it is `:pending` or `:unscheduled`.
-    #
-    # @return [Boolean] true if successfully cancelled else false
-    #
-    # @deprecated Use {#cancel} instead.
-    def stop
-      deprecated_method 'stop', 'cancel'
-      cancel
-    end
-
     # Reschedule the task using the original delay and the current time.
     # A task can only be reset while it is `:pending`.
     #
@@ -281,7 +245,9 @@ module Concurrent
     #
     # @raise [ArgumentError] When given a time that is in the past
     def reschedule(delay)
-      synchronize{ ns_reschedule(calculate_delay!(delay)) }
+      delay = delay.to_f
+      raise ArgumentError.new('seconds must be greater than zero') if delay < 0.0
+      synchronize{ ns_reschedule(delay) }
     end
 
     # Execute an `:unscheduled` `ScheduledTask`. Immediately sets the state to `:pending`
@@ -306,8 +272,6 @@ module Concurrent
     # @return [ScheduledTask] the newly created `ScheduledTask` in the `:pending` state
     #
     # @raise [ArgumentError] if no block is given
-    #
-    # @!macro deprecated_scheduling_by_clock_time
     def self.execute(delay, opts = {}, &task)
       new(delay, opts, &task).execute
     end
@@ -348,29 +312,5 @@ module Concurrent
       return false unless ns_check_state?(:pending)
       @parent.send(:remove_task, self) && ns_schedule(delay)
     end
-
-    # Calculate the actual delay in seconds based on the given delay.
-    #
-    # @param [Float] delay the number of seconds to wait for before executing the task
-    #
-    # @return [Float] the number of seconds to delay
-    #
-    # @raise [ArgumentError] if the intended execution time is not in the future
-    # @raise [ArgumentError] if no block is given
-    #
-    # @!macro deprecated_scheduling_by_clock_time
-    #
-    # @!visibility private
-    def calculate_delay!(delay)
-      if delay.is_a?(Time)
-        deprecated 'Use an interval not a clock time; schedule is now based on a monotonic clock'
-        now = Time.now
-        raise ArgumentError.new('schedule time must be in the future') if delay <= now
-        delay.to_f - now.to_f
-      else
-        raise ArgumentError.new('seconds must be greater than zero') if delay.to_f < 0.0
-        delay.to_f
-      end
-    end
   end
 end