concurrent-ruby 1.0.5 → 1.1.10

data/lib/concurrent-ruby/concurrent/re_include.rb

@@ -0,0 +1,58 @@
+module Concurrent
+
+  # Methods form module A included to a module B, which is already included into class C,
+  # will not be visible in the C class. If this module is extended to B then A's methods
+  # are correctly made visible to C.
+  #
+  # @example
+  #   module A
+  #     def a
+  #       :a
+  #     end
+  #   end
+  #
+  #   module B1
+  #   end
+  #
+  #   class C1
+  #     include B1
+  #   end
+  #
+  #   module B2
+  #     extend Concurrent::ReInclude
+  #   end
+  #
+  #   class C2
+  #     include B2
+  #   end
+  #
+  #   B1.send :include, A
+  #   B2.send :include, A
+  #
+  #   C1.new.respond_to? :a # => false
+  #   C2.new.respond_to? :a # => true
+  module ReInclude
+    # @!visibility private
+    def included(base)
+      (@re_include_to_bases ||= []) << [:include, base]
+      super(base)
+    end
+
+    # @!visibility private
+    def extended(base)
+      (@re_include_to_bases ||= []) << [:extend, base]
+      super(base)
+    end
+
+    # @!visibility private
+    def include(*modules)
+      result = super(*modules)
+      modules.reverse.each do |module_being_included|
+        (@re_include_to_bases ||= []).each do |method, mod|
+          mod.send method, module_being_included
+        end
+      end
+      result
+    end
+  end
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/scheduled_task.rb

@@ -58,29 +58,42 @@ module Concurrent
   # @example Basic usage
   #
   #   require 'concurrent'
-  #   require 'thread'   # for Queue
-  #   require 'open-uri' # for open(uri)
+  #   require 'csv'
+  #   require 'open-uri'
   #
   #   class Ticker
-  #     def get_year_end_closing(symbol, year)
-  #       uri = "http://ichart.finance.yahoo.com/table.csv?s=#{symbol}&a=11&b=01&c=#{year}&d=11&e=31&f=#{year}&g=m"
-  #       data = open(uri) {|f| f.collect{|line| line.strip } }
-  #       data[1].split(',')[4].to_f
-  #     end
+  #     def get_year_end_closing(symbol, year, api_key)
+  #      uri = "https://www.alphavantage.co/query?function=TIME_SERIES_MONTHLY&symbol=#{symbol}&apikey=#{api_key}&datatype=csv"
+  #      data = []
+  #      csv = URI.parse(uri).read
+  #      if csv.include?('call frequency')
+  #        return :rate_limit_exceeded
+  #      end
+  #      CSV.parse(csv, headers: true) do |row|
+  #        data << row['close'].to_f if row['timestamp'].include?(year.to_s)
+  #      end
+  #      year_end = data.first
+  #      year_end
+  #    rescue => e
+  #      p e
+  #    end
   #   end
   #
+  #   api_key = ENV['ALPHAVANTAGE_KEY']
+  #   abort(error_message) unless api_key
+  #
   #   # Future
-  #   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013) }
+  #   price = Concurrent::Future.execute{ Ticker.new.get_year_end_closing('TWTR', 2013, api_key) }
   #   price.state #=> :pending
-  #   sleep(1)    # do other stuff
-  #   price.value #=> 63.65
-  #   price.state #=> :fulfilled
+  #   price.pending? #=> true
+  #   price.value(0) #=> nil (does not block)
   #
-  #   # ScheduledTask
-  #   task = Concurrent::ScheduledTask.execute(2){ Ticker.new.get_year_end_closing('INTC', 2013) }
-  #   task.state #=> :pending
-  #   sleep(3)   # do other stuff
-  #   task.value #=> 25.96
+  #    sleep(1)    # do other stuff
+  #
+  #   price.value #=> 63.65 (after blocking if necessary)
+  #   price.state #=> :fulfilled
+  #   price.fulfilled? #=> true
+  #   price.value #=> 63.65
   #
   # @example Successful task execution
   #

data/lib/concurrent-ruby/concurrent/set.rb

@@ -0,0 +1,74 @@
+require 'concurrent/utility/engine'
+require 'concurrent/thread_safe/util'
+require 'set'
+
+module Concurrent
+
+  # @!macro concurrent_set
+  #
+  #   A thread-safe subclass of Set. 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`.
+  #
+  #   @note `a += b` is **not** a **thread-safe** operation on
+  #     `Concurrent::Set`. It reads Set `a`, then it creates new `Concurrent::Set`
+  #     which is union of `a` and `b`, then it writes the union to `a`.
+  #     The read and write are independent operations they do not form a single atomic
+  #     operation therefore when two `+=` operations are executed concurrently updates
+  #     may be lost. Use `#merge` instead.
+  #
+  #   @see http://ruby-doc.org/stdlib-2.4.0/libdoc/set/rdoc/Set.html Ruby standard library `Set`
+
+  # @!macro internal_implementation_note
+  SetImplementation = case
+                      when Concurrent.on_cruby?
+                        # The CRuby implementation of Set is written in Ruby itself and is
+                        # not thread safe for certain methods.
+                        require 'monitor'
+                        require 'concurrent/thread_safe/util/data_structures'
+
+                        class CRubySet < ::Set
+                        end
+
+                        ThreadSafe::Util.make_synchronized_on_cruby CRubySet
+                        CRubySet
+
+                      when Concurrent.on_jruby?
+                        require 'jruby/synchronized'
+
+                        class JRubySet < ::Set
+                          include JRuby::Synchronized
+                        end
+
+                        JRubySet
+
+                      when Concurrent.on_rbx?
+                        require 'monitor'
+                        require 'concurrent/thread_safe/util/data_structures'
+
+                        class RbxSet < ::Set
+                        end
+
+                        ThreadSafe::Util.make_synchronized_on_rbx RbxSet
+                        RbxSet
+
+                      when Concurrent.on_truffleruby?
+                        require 'concurrent/thread_safe/util/data_structures'
+
+                        class TruffleRubySet < ::Set
+                        end
+
+                        ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubySet
+                        TruffleRubySet
+
+                      else
+                        warn 'Possibly unsupported Ruby implementation'
+                        ::Set
+                      end
+  private_constant :SetImplementation
+
+  # @!macro concurrent_set
+  class Set < SetImplementation
+  end
+end
+

data/lib/{concurrent → concurrent-ruby/concurrent}/settable_struct.rb

@@ -9,7 +9,7 @@ module Concurrent
   # or any time thereafter. Attempting to assign a value to a member
   # that has already been set will result in a `Concurrent::ImmutabilityError`.
   #
-  # @see http://ruby-doc.org/core-2.2.0/Struct.html Ruby standard library `Struct`
+  # @see http://ruby-doc.org/core/Struct.html Ruby standard library `Struct`
   # @see http://en.wikipedia.org/wiki/Final_(Java) Java `final` keyword
   module SettableStruct
     include Synchronization::AbstractStruct
@@ -91,6 +91,16 @@ module Concurrent
       raise NameError.new("no member '#{member}' in struct")
     end
 
+    private
+
+    # @!visibility private
+    def initialize_copy(original)
+      synchronize do
+        super(original)
+        ns_initialize_copy
+      end
+    end
+
     # @!macro struct_new
     def self.new(*args, &block)
       clazz_name = nil
@@ -107,6 +117,7 @@ module Concurrent
         synchronize do
           clazz = Synchronization::AbstractStruct.define_struct_class(SettableStruct, Synchronization::LockableObject, name, members, &block)
           members.each_with_index do |member, index|
+            clazz.send :remove_method, member if clazz.instance_methods.include? member
             clazz.send(:define_method, member) do
               synchronize { @values[index] }
             end

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/abstract_lockable_object.rb

@@ -6,7 +6,7 @@ module Concurrent
 
       protected
 
-      # @!macro [attach] synchronization_object_method_synchronize
+      # @!macro synchronization_object_method_synchronize
       #
       #   @yield runs the block synchronized against this object,
       #     equivalent of java's `synchronize(this) {}`
@@ -15,7 +15,7 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ns_wait_until
+      # @!macro synchronization_object_method_ns_wait_until
       #
       #   Wait until condition is met or timeout passes,
       #   protects against spurious wake-ups.
@@ -45,7 +45,7 @@ module Concurrent
         end
       end
 
-      # @!macro [attach] synchronization_object_method_ns_wait
+      # @!macro synchronization_object_method_ns_wait
       #
       #   Wait until another thread calls #signal or #broadcast,
       #   spurious wake-ups can happen.
@@ -63,7 +63,7 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ns_signal
+      # @!macro synchronization_object_method_ns_signal
       #
       #   Signal one waiting thread.
       #   @return [self]
@@ -78,7 +78,7 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ns_broadcast
+      # @!macro synchronization_object_method_ns_broadcast
       #
       #   Broadcast to all waiting threads.
       #   @return [self]

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/abstract_struct.rb

@@ -11,7 +11,7 @@ module Concurrent
         ns_initialize(*values)
       end
 
-      # @!macro [attach] struct_length
+      # @!macro struct_length
       #
       #   Returns the number of struct members.
       #
@@ -21,7 +21,7 @@ module Concurrent
       end
       alias_method :size, :length
 
-      # @!macro [attach] struct_members
+      # @!macro struct_members
       #
       #   Returns the struct members as an array of symbols.
       #
@@ -115,9 +115,20 @@ module Concurrent
         self.class.new(*self.to_h.merge(other, &block).values)
       end
 
+      # @!visibility private
+      def ns_initialize_copy
+        @values = @values.map do |val|
+          begin
+            val.clone
+          rescue TypeError
+            val
+          end
+        end
+      end
+
       # @!visibility private
       def pr_underscore(clazz)
-        word = clazz.to_s
+        word = clazz.to_s.dup # dup string to workaround JRuby 9.2.0.0 bug https://github.com/jruby/jruby/issues/5229
         word.gsub!(/::/, '/')
         word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
         word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
@@ -138,18 +149,21 @@ module Concurrent
         end
         unless name.nil?
           begin
+            parent.send :remove_const, name if parent.const_defined?(name, false)
             parent.const_set(name, clazz)
-            parent.const_get(name)
+            clazz
           rescue NameError
             raise NameError.new("identifier #{name} needs to be constant")
           end
         end
         members.each_with_index do |member, index|
+          clazz.send :remove_method, member if clazz.instance_methods.include? member
           clazz.send(:define_method, member) do
             @values[index]
           end
         end
         clazz.class_exec(&block) unless block.nil?
+        clazz.singleton_class.send :alias_method, :[], :new
         clazz
       end
     end

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/condition.rb

@@ -1,5 +1,7 @@
 module Concurrent
   module Synchronization
+
+    # @!visibility private
     # TODO (pitr-ch 04-Dec-2016): should be in edge
     class Condition < LockableObject
       safe_initialization!

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/jruby_object.rb

@@ -3,6 +3,7 @@ module Concurrent
 
     if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
 
+      # @!visibility private
       module JRubyAttrVolatile
         def self.included(base)
           base.extend(ClassMethods)

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/lock.rb

@@ -1,5 +1,7 @@
 module Concurrent
   module Synchronization
+
+    # @!visibility private
     # TODO (pitr-ch 04-Dec-2016): should be in edge
     class Lock < LockableObject
       # TODO use JavaReentrantLock on JRuby

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/lockable_object.rb

@@ -4,19 +4,17 @@ module Concurrent
     # @!visibility private
     # @!macro internal_implementation_note
     LockableObjectImplementation = case
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
-                                     MriMonitorLockableObject
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
-                                     MriMutexLockableObject
+                                   when Concurrent.on_cruby?
+                                     MutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject
                                    when Concurrent.on_rbx?
                                      RbxLockableObject
-                                   when Concurrent.on_truffle?
-                                     MriMutexLockableObject
+                                   when Concurrent.on_truffleruby?
+                                     MutexLockableObject
                                    else
                                      warn 'Possibly unsupported Ruby implementation'
-                                     MriMonitorLockableObject
+                                     MonitorLockableObject
                                    end
     private_constant :LockableObjectImplementation
 
@@ -26,12 +24,12 @@ module Concurrent
     #   the classes using it. Use {Synchronization::Object} not this abstract class.
     #
     #   @note this object does not support usage together with
-    #     [`Thread#wakeup`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-wakeup)
-    #     and [`Thread#raise`](http://ruby-doc.org/core-2.2.0/Thread.html#method-i-raise).
+    #     [`Thread#wakeup`](http://ruby-doc.org/core/Thread.html#method-i-wakeup)
+    #     and [`Thread#raise`](http://ruby-doc.org/core/Thread.html#method-i-raise).
     #     `Thread#sleep` and `Thread#wakeup` will work as expected but mixing `Synchronization::Object#wait` and
     #     `Thread#wakeup` will not work on all platforms.
     #
-    #   @see {Event} implementation as an example of this class use
+    #   @see Event implementation as an example of this class use
     #
     #   @example simple
     #     class AnClass < Synchronization::Object

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/mri_object.rb

@@ -1,6 +1,7 @@
 module Concurrent
   module Synchronization
 
+    # @!visibility private
     module MriAttrVolatile
       def self.included(base)
         base.extend(ClassMethods)

data/lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb

@@ -0,0 +1,88 @@
+module Concurrent
+  # noinspection RubyInstanceVariableNamingConvention
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    module ConditionSignalling
+      protected
+
+      def ns_signal
+        @__Condition__.signal
+        self
+      end
+
+      def ns_broadcast
+        @__Condition__.broadcast
+        self
+      end
+    end
+
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MutexLockableObject < AbstractLockableObject
+      include ConditionSignalling
+
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__Lock__      = ::Mutex.new
+        @__Condition__ = ::ConditionVariable.new
+      end
+
+      def initialize_copy(other)
+        super
+        @__Lock__      = ::Mutex.new
+        @__Condition__ = ::ConditionVariable.new
+      end
+
+      protected
+
+      def synchronize
+        if @__Lock__.owned?
+          yield
+        else
+          @__Lock__.synchronize { yield }
+        end
+      end
+
+      def ns_wait(timeout = nil)
+        @__Condition__.wait @__Lock__, timeout
+        self
+      end
+    end
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    class MonitorLockableObject < AbstractLockableObject
+      include ConditionSignalling
+
+      safe_initialization!
+
+      def initialize(*defaults)
+        super(*defaults)
+        @__Lock__      = ::Monitor.new
+        @__Condition__ = @__Lock__.new_cond
+      end
+
+      def initialize_copy(other)
+        super
+        @__Lock__      = ::Monitor.new
+        @__Condition__ = @__Lock__.new_cond
+      end
+
+      protected
+
+      def synchronize # TODO may be a problem with lock.synchronize { lock.wait }
+        @__Lock__.synchronize { yield }
+      end
+
+      def ns_wait(timeout = nil)
+        @__Condition__.wait timeout
+        self
+      end
+    end
+  end
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/object.rb

@@ -10,9 +10,10 @@ module Concurrent
                              JRubyObject
                            when Concurrent.on_rbx?
                              RbxObject
-                           when Concurrent.on_truffle?
-                             TruffleObject
+                           when Concurrent.on_truffleruby?
+                             TruffleRubyObject
                            else
+                             warn 'Possibly unsupported Ruby implementation'
                              MriObject
                            end
     private_constant :ObjectImplementation
@@ -26,15 +27,15 @@ module Concurrent
 
       # @!method self.attr_volatile(*names)
       #   Creates methods for reading and writing (as `attr_accessor` does) to a instance variable with
-      #   volatile (Java) semantic. The instance variable should be accessed oly through generated methods.
+      #   volatile (Java) semantic. The instance variable should be accessed only through generated methods.
       #
-      #   @param [Array<Symbol>] names of the instance variables to be volatile
-      #   @return [Array<Symbol>] names of defined method names
+      #   @param [::Array<Symbol>] names of the instance variables to be volatile
+      #   @return [::Array<Symbol>] names of defined method names
 
       # Has to be called by children.
       def initialize
         super
-        initialize_volatile_with_cas
+        __initialize_atomic_fields__
       end
 
       # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
@@ -48,10 +49,12 @@ module Concurrent
       #       @AFinalValue = 'value' # published safely, does not have to be synchronized
       #     end
       #   end
+      # @return [true]
       def self.safe_initialization!
         # define only once, and not again in children
         return if safe_initialization?
 
+        # @!visibility private
         def self.new(*args, &block)
           object = super(*args, &block)
         ensure
@@ -69,6 +72,8 @@ module Concurrent
 
       # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains
       # any instance variables with CamelCase names and isn't {.safe_initialization?}.
+      # @raise when offend found
+      # @return [true]
       def self.ensure_safe_initialization_when_final_fields_are_present
         Object.class_eval do
           def self.new(*args, &block)
@@ -80,6 +85,7 @@ module Concurrent
             end
           end
         end
+        true
       end
 
       # Creates methods for reading and writing to a instance variable with
@@ -88,13 +94,30 @@ module Concurrent
       # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
       # `swap_value(new_value) #=> old_value`,
       # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.
-      # @param [Array<Symbol>] names of the instance variables to be volatile with CAS.
-      # @return [Array<Symbol>] names of defined method names.
+      # @param [::Array<Symbol>] names of the instance variables to be volatile with CAS.
+      # @return [::Array<Symbol>] names of defined method names.
+      # @!macro attr_atomic
+      #   @!method $1
+      #     @return [Object] The $1.
+      #   @!method $1=(new_$1)
+      #     Set the $1.
+      #     @return [Object] new_$1.
+      #   @!method swap_$1(new_$1)
+      #     Set the $1 to new_$1 and return the old $1.
+      #     @return [Object] old $1
+      #   @!method compare_and_set_$1(expected_$1, new_$1)
+      #     Sets the $1 to new_$1 if the current $1 is expected_$1
+      #     @return [true, false]
+      #   @!method update_$1(&block)
+      #     Updates the $1 using the block.
+      #     @yield [Object] Calculate a new $1 using given (old) $1
+      #     @yieldparam [Object] old $1
+      #     @return [Object] new $1
       def self.attr_atomic(*names)
-        @volatile_cas_fields ||= []
-        @volatile_cas_fields += names
+        @__atomic_fields__ ||= []
+        @__atomic_fields__ += names
         safe_initialization!
-        define_initialize_volatile_with_cas
+        define_initialize_atomic_fields
 
         names.each do |name|
           ivar = :"@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }}"
@@ -123,29 +146,36 @@ module Concurrent
         names.flat_map { |n| [n, :"#{n}=", :"swap_#{n}", :"compare_and_set_#{n}", :"update_#{n}"] }
       end
 
-      # @param [true,false] inherited should inherited volatile with CAS fields be returned?
-      # @return [Array<Symbol>] Returns defined volatile with CAS fields on this class.
-      def self.volatile_cas_fields(inherited = true)
-        @volatile_cas_fields ||= []
-        ((superclass.volatile_cas_fields if superclass.respond_to?(:volatile_cas_fields) && inherited) || []) +
-            @volatile_cas_fields
+      # @param [true, false] inherited should inherited volatile with CAS fields be returned?
+      # @return [::Array<Symbol>] Returns defined volatile with CAS fields on this class.
+      def self.atomic_attributes(inherited = true)
+        @__atomic_fields__ ||= []
+        ((superclass.atomic_attributes if superclass.respond_to?(:atomic_attributes) && inherited) || []) + @__atomic_fields__
+      end
+
+      # @return [true, false] is the attribute with name atomic?
+      def self.atomic_attribute?(name)
+        atomic_attributes.include? name
       end
 
       private
 
-      def self.define_initialize_volatile_with_cas
-        assignments = @volatile_cas_fields.map { |name| "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = AtomicReference.new(nil)" }.join("\n")
-        class_eval <<-RUBY
-          def initialize_volatile_with_cas
+      def self.define_initialize_atomic_fields
+        assignments = @__atomic_fields__.map do |name|
+          "@Atomic#{name.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }} = Concurrent::AtomicReference.new(nil)"
+        end.join("\n")
+
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def __initialize_atomic_fields__
             super
             #{assignments}
           end
         RUBY
       end
 
-      private_class_method :define_initialize_volatile_with_cas
+      private_class_method :define_initialize_atomic_fields
 
-      def initialize_volatile_with_cas
+      def __initialize_atomic_fields__
       end
 
     end

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/rbx_lockable_object.rb

@@ -12,6 +12,12 @@ module Concurrent
         @__owner__   = nil
       end
 
+      def initialize_copy(other)
+        super
+        @__Waiters__ = []
+        @__owner__   = nil
+      end
+
       protected
 
       def synchronize(&block)

data/lib/{concurrent → concurrent-ruby/concurrent}/synchronization/rbx_object.rb

@@ -1,6 +1,7 @@
 module Concurrent
   module Synchronization
 
+    # @!visibility private
     module RbxAttrVolatile
       def self.included(base)
         base.extend(ClassMethods)