concurrent-ruby 0.9.2-java → 1.0.0-java

data/lib/concurrent/lazy_register.rb

@@ -7,19 +7,22 @@ module Concurrent
   #
   # @example
   #   register = Concurrent::LazyRegister.new
-  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
+  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
   #   register[:key]
   #   #=> nil
   #   register.add(:key) { Concurrent::Actor.spawn!(Actor::AdHoc, :ping) { -> message { message } } }
-  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
+  #   #=> #<Concurrent::LazyRegister:0x007fd7ecd5e230 @Data=#<Concurrent::AtomicReference:0x007fd7ecd5e1e0>>
   #   register[:key]
   #   #=> #<Concurrent::Actor::Reference /ping (Concurrent::Actor::AdHoc)>
   #
   # @!macro edge_warning
-  class LazyRegister
+  class LazyRegister < Synchronization::Object
+
+    private(*attr_atomic(:data))
 
     def initialize
-      @data = AtomicReference.new(Hash.new)
+      super
+      self.data = {}
     end
 
     # Element reference. Retrieves the value object corresponding to the
@@ -31,7 +34,7 @@ module Concurrent
     #
     # @raise Exception when the initialization block fails
     def [](key)
-      delay = @data.get[key]
+      delay = data[key]
       delay ? delay.value! : nil
     end
 
@@ -40,7 +43,7 @@ module Concurrent
     # @param [Object] key
     # @return [true, false] if the key is registered
     def registered?(key)
-      @data.get.key?(key)
+      data.key?(key)
     end
 
     alias_method :key?, :registered?
@@ -55,7 +58,7 @@ module Concurrent
     # @return [LazyRegister] self
     def register(key, &block)
       delay = Delay.new(executor: :immediate, &block)
-      @data.update { |h| h.merge(key => delay) }
+      update_data { |h| h.merge(key => delay) }
       self
     end
 
@@ -68,7 +71,7 @@ module Concurrent
     #
     # @return [LazyRegister] self
     def unregister(key)
-      @data.update { |h| h.dup.tap { |j| j.delete(key) } }
+      update_data { |h| h.dup.tap { |j| j.delete(key) } }
       self
     end
 

data/lib/concurrent/map.rb

@@ -0,0 +1,180 @@
+require 'thread'
+require 'concurrent/constants'
+require 'concurrent/synchronization'
+
+module Concurrent
+  # @!visibility private
+  module Collection
+
+    # @!visibility private
+    MapImplementation = if Concurrent.java_extensions_loaded?
+                          # noinspection RubyResolve
+                          JRubyMapBackend
+                        elsif defined?(RUBY_ENGINE)
+                          case RUBY_ENGINE
+                          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/maybe.rb

@@ -1,3 +1,5 @@
+require 'concurrent/synchronization'
+
 module Concurrent
 
   # A `Maybe` encapsulates an optional value. A `Maybe` either contains a value
@@ -99,8 +101,9 @@ module Concurrent
   #
   # @see https://hackage.haskell.org/package/base-4.2.0.1/docs/Data-Maybe.html Haskell Data.Maybe
   # @see https://github.com/purescript/purescript-maybe/blob/master/docs/Data.Maybe.md PureScript Data.Maybe
-  class Maybe
+  class Maybe < Synchronization::Object
     include Comparable
+    safe_initialization!
 
     # Indicates that the given attribute has not been set.
     # When `Just` the {#nothing} getter will return `NONE`.
@@ -168,7 +171,7 @@ module Concurrent
     end
 
     # Is this `Maybe` a `Just` (successfully fulfilled with a value)?
-    # 
+    #
     # @return [Boolean] True if `Just` or false if `Nothing`.
     def just?
       ! nothing?
@@ -176,7 +179,7 @@ module Concurrent
     alias :fulfilled? :just?
 
     # Is this `Maybe` a `nothing` (rejected with an exception upon fulfillment)?
-    # 
+    #
     # @return [Boolean] True if `Nothing` or false if `Just`.
     def nothing?
       @nothing != NONE

data/lib/concurrent/mutable_struct.rb

@@ -75,7 +75,7 @@ module Concurrent
     alias_method :to_s, :inspect
 
     # @!macro [attach] struct_merge
-    # 
+    #
     #   Returns a new struct containing the contents of `other` and the contents
     #   of `self`. If no block is specified, the value for entries with duplicate
     #   keys will be that of `other`. Otherwise the value for each duplicate key
@@ -98,7 +98,7 @@ module Concurrent
     # @!macro [attach] struct_to_h
     #
     #   Returns a hash containing the names and values for the struct’s members.
-    #   
+    #
     #   @return [Hash] the names and values for the struct’s members
     def to_h
       synchronize { ns_to_h }
@@ -184,8 +184,9 @@ module Concurrent
     #   @raise [IndexError] if the index is out of range.
     def []=(member, value)
       if member.is_a? Integer
-        if member >= @values.length
-          raise IndexError.new("offset #{member} too large for struct(size:#{@values.length})")
+        length = synchronize { @values.length }
+        if member >= length
+          raise IndexError.new("offset #{member} too large for struct(size:#{length})")
         end
         synchronize { @values[member] = value }
       else
@@ -206,10 +207,10 @@ module Concurrent
       FACTORY.define_struct(clazz_name, args, &block)
     end
 
-    FACTORY = Class.new(Synchronization::Object) do
+    FACTORY = Class.new(Synchronization::LockableObject) do
       def define_struct(name, members, &block)
         synchronize do
-          clazz = Synchronization::AbstractStruct.define_struct_class(MutableStruct, Synchronization::Object, name, members, &block)
+          clazz = Synchronization::AbstractStruct.define_struct_class(MutableStruct, Synchronization::LockableObject, name, members, &block)
           members.each_with_index do |member, index|
             clazz.send(:define_method, member) do
               synchronize { @values[index] }

data/lib/concurrent/mvar.rb

@@ -1,4 +1,5 @@
 require 'concurrent/concern/dereferenceable'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -34,9 +35,9 @@ module Concurrent
   # 2. S. Peyton Jones, A. Gordon, and S. Finne. [Concurrent Haskell](http://dl.acm.org/citation.cfm?id=237794).
   #    In Proceedings of the 23rd Symposium on Principles of Programming Languages
   #    (PoPL), 1996.
-  class MVar
-
+  class MVar < Synchronization::Object
     include Concern::Dereferenceable
+    safe_initialization!
 
     # Unique value that represents that an `MVar` was empty
     EMPTY = Object.new
@@ -78,6 +79,23 @@ module Concurrent
       end
     end
 
+    # acquires lock on the from an `MVAR`, yields the value to provided block,
+    # and release lock. A timeout can be set to limit the time spent blocked,
+    # in which case it returns `TIMEOUT` if the time is exceeded.
+    # @return [Object] the value returned by the block, or `TIMEOUT`
+    def borrow(timeout = nil)
+      @mutex.synchronize do
+        wait_for_full(timeout)
+
+        # if we timeoud out we'll still be empty
+        if unlocked_full?
+          yield @value
+        else
+          TIMEOUT
+        end
+      end
+    end
+
     # Put a value into an `MVar`, blocking if there is already a value until
     # it is empty. A timeout can be set to limit the time spent blocked, in
     # which case it returns `TIMEOUT` if the time is exceeded.
@@ -183,6 +201,12 @@ module Concurrent
       !empty?
     end
 
+    protected
+
+    def synchronize(&block)
+      @mutex.synchronize(&block)
+    end
+
     private
 
     def unlocked_empty?

data/lib/concurrent/{executor/executor.rb → options.rb}

@@ -1,12 +1,11 @@
+# This file has circular require issues. It must be autoloaded.
+
 require 'concurrent/configuration'
-require 'concurrent/concern/deprecation'
-require 'concurrent/executor/executor_service'
 
 module Concurrent
 
   # @!visibility private
-  module Executor
-    extend Concern::Deprecation
+  module Options
 
     # Get the requested `Executor` based on the values set in the options hash.
     #
@@ -20,25 +19,8 @@ module Concurrent
     #
     # @!visibility private
     def self.executor_from_options(opts = {}) # :nodoc:
-      case
-      when opts.key?(:executor)
-        if opts[:executor].nil?
-          nil
-        else
-          executor(opts[:executor])
-        end
-      when opts.key?(:operation) || opts.key?(:task)
-        if opts[:operation] == true || opts[:task] == false
-          deprecated 'use `executor: :fast` instead'
-          return Concurrent.global_fast_executor
-        end
-
-        if opts[:operation] == false || opts[:task] == true
-          deprecated 'use `executor: :io` instead'
-          return Concurrent.global_io_executor
-        end
-
-        raise ArgumentError.new("executor '#{opts[:executor]}' not recognized")
+      if identifier = opts.fetch(:executor, nil)
+        executor(identifier)
       else
         nil
       end
@@ -52,12 +34,6 @@ module Concurrent
         Concurrent.global_io_executor
       when :immediate
         Concurrent.global_immediate_executor
-      when :operation
-        deprecated 'use `executor: :fast` instead'
-        Concurrent.global_fast_executor
-      when :task
-        deprecated 'use `executor: :io` instead'
-        Concurrent.global_io_executor
       when Concurrent::ExecutorService
         executor_identifier
       else

data/lib/concurrent/promise.rb

@@ -1,10 +1,12 @@
 require 'thread'
+require 'concurrent/constants'
 require 'concurrent/errors'
 require 'concurrent/ivar'
-require 'concurrent/executor/executor'
 
 module Concurrent
 
+  autoload :Options, 'concurrent/options'
+
   PromiseExecutionError = Class.new(StandardError)
 
   # Promises are inspired by the JavaScript [Promises/A](http://wiki.commonjs.org/wiki/Promises/A)
@@ -205,7 +207,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 +256,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
@@ -302,7 +304,7 @@ module Concurrent
     # @return [Promise] the new promise
     def then(rescuer = nil, &block)
       raise ArgumentError.new('rescuers and block are both missing') if rescuer.nil? && !block_given?
-      block = Proc.new { |result| result } if block.nil?
+      block = Proc.new { |result| result } unless block_given?
       child = Promise.new(
         parent: self,
         executor: @executor,
@@ -441,7 +443,7 @@ module Concurrent
     def ns_initialize(value, opts)
       super
 
-      @executor = Executor.executor_from_options(opts) || Concurrent.global_io_executor
+      @executor = Options.executor_from_options(opts) || Concurrent.global_io_executor
       @args = get_arguments_from(opts)
 
       @parent = opts.fetch(:parent) { nil }