concurrent-ruby 1.1.5 → 1.2.2

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

@@ -57,30 +57,43 @@ module Concurrent
   #
   # @example Basic usage
   #
-  #   require 'concurrent'
-  #   require 'thread'   # for Queue
-  #   require 'open-uri' # for open(uri)
+  #   require 'concurrent/scheduled_task'
+  #   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 → concurrent-ruby/concurrent}/set.rb

@@ -11,21 +11,27 @@ module Concurrent
   #   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.
+  #     `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?
-                        # Because MRI never runs code in parallel, the existing
-                        # non-thread-safe structures should usually work fine.
-                        ::Set
+                        # 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'
@@ -33,16 +39,8 @@ module Concurrent
                         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 Concurrent::RbxSet
-                        RbxSet
+                        JRubySet
 
                       when Concurrent.on_truffleruby?
                         require 'concurrent/thread_safe/util/data_structures'
@@ -50,7 +48,7 @@ module Concurrent
                         class TruffleRubySet < ::Set
                         end
 
-                        ThreadSafe::Util.make_synchronized_on_truffleruby Concurrent::TruffleRubySet
+                        ThreadSafe::Util.make_synchronized_on_truffleruby TruffleRubySet
                         TruffleRubySet
 
                       else

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

@@ -1,6 +1,6 @@
-require 'concurrent/synchronization/abstract_struct'
 require 'concurrent/errors'
-require 'concurrent/synchronization'
+require 'concurrent/synchronization/abstract_struct'
+require 'concurrent/synchronization/lockable_object'
 
 module Concurrent
 
@@ -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

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

@@ -1,3 +1,7 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/synchronization/object'
+
 module Concurrent
   module Synchronization
 
@@ -34,7 +38,7 @@ module Concurrent
         if timeout
           wait_until = Concurrent.monotonic_time + timeout
           loop do
-            now              = Concurrent.monotonic_time
+            now = Concurrent.monotonic_time
             condition_result = condition.call
             return condition_result if now >= wait_until || condition_result
             ns_wait wait_until - now

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

@@ -4,10 +4,8 @@ module Concurrent
     # @!visibility private
     # @!macro internal_implementation_note
     class AbstractObject
-
-      # @abstract has to be implemented based on Ruby runtime
       def initialize
-        raise NotImplementedError
+        # nothing to do
       end
 
       # @!visibility private

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

@@ -115,6 +115,17 @@ 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.dup # dup string to workaround JRuby 9.2.0.0 bug https://github.com/jruby/jruby/issues/5229

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

@@ -1,3 +1,5 @@
+require 'concurrent/synchronization/lockable_object'
+
 module Concurrent
   module Synchronization
 

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

@@ -0,0 +1,29 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+module Concurrent
+  module Synchronization
+    case
+    when Concurrent.on_cruby?
+      def self.full_memory_barrier
+        # relying on undocumented behavior of CRuby, GVL acquire has lock which ensures visibility of ivars
+        # https://github.com/ruby/ruby/blob/ruby_2_2/thread_pthread.c#L204-L211
+      end
+
+    when Concurrent.on_jruby?
+      require 'concurrent/utility/native_extension_loader'
+      def self.full_memory_barrier
+        JRubyAttrVolatile.full_memory_barrier
+      end
+
+    when Concurrent.on_truffleruby?
+      def self.full_memory_barrier
+        TruffleRuby.full_memory_barrier
+      end
+
+    else
+      warn 'Possibly unsupported Ruby implementation'
+      def self.full_memory_barrier
+      end
+    end
+  end
+end

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

@@ -1,7 +1,9 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
 module Concurrent
   module Synchronization
 
-    if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
+    if Concurrent.on_jruby?
 
       # @!visibility private
       # @!macro internal_implementation_note

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

@@ -1,3 +1,5 @@
+require 'concurrent/synchronization/lockable_object'
+
 module Concurrent
   module Synchronization
 

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

@@ -1,17 +1,18 @@
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/abstract_lockable_object'
+require 'concurrent/synchronization/mutex_lockable_object'
+require 'concurrent/synchronization/jruby_lockable_object'
+
 module Concurrent
   module Synchronization
 
     # @!visibility private
     # @!macro internal_implementation_note
     LockableObjectImplementation = case
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:<=, 1, 9, 3)
-                                     MonitorLockableObject
-                                   when Concurrent.on_cruby? && Concurrent.ruby_version(:>, 1, 9, 3)
+                                   when Concurrent.on_cruby?
                                      MutexLockableObject
                                    when Concurrent.on_jruby?
                                      JRubyLockableObject
-                                   when Concurrent.on_rbx?
-                                     RbxLockableObject
                                    when Concurrent.on_truffleruby?
                                      MutexLockableObject
                                    else
@@ -26,8 +27,8 @@ 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.
     #

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

@@ -1,5 +1,6 @@
+require 'concurrent/synchronization/abstract_lockable_object'
+
 module Concurrent
-  # noinspection RubyInstanceVariableNamingConvention
   module Synchronization
 
     # @!visibility private
@@ -26,8 +27,14 @@ module Concurrent
 
       safe_initialization!
 
-      def initialize(*defaults)
-        super(*defaults)
+      def initialize
+        super()
+        @__Lock__      = ::Mutex.new
+        @__Condition__ = ::ConditionVariable.new
+      end
+
+      def initialize_copy(other)
+        super
         @__Lock__      = ::Mutex.new
         @__Condition__ = ::ConditionVariable.new
       end
@@ -55,8 +62,14 @@ module Concurrent
 
       safe_initialization!
 
-      def initialize(*defaults)
-        super(*defaults)
+      def initialize
+        super()
+        @__Lock__      = ::Monitor.new
+        @__Condition__ = @__Lock__.new_cond
+      end
+
+      def initialize_copy(other)
+        super
         @__Lock__      = ::Monitor.new
         @__Condition__ = @__Lock__.new_cond
       end

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

@@ -1,28 +1,20 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/synchronization/safe_initialization'
+require 'concurrent/synchronization/volatile'
+require 'concurrent/atomic/atomic_reference'
+
 module Concurrent
   module Synchronization
 
-    # @!visibility private
-    # @!macro internal_implementation_note
-    ObjectImplementation = case
-                           when Concurrent.on_cruby?
-                             MriObject
-                           when Concurrent.on_jruby?
-                             JRubyObject
-                           when Concurrent.on_rbx?
-                             RbxObject
-                           when Concurrent.on_truffleruby?
-                             TruffleRubyObject
-                           else
-                             warn 'Possibly unsupported Ruby implementation'
-                             MriObject
-                           end
-    private_constant :ObjectImplementation
-
     # Abstract object providing final, volatile, ans CAS extensions to build other concurrent abstractions.
     # - final instance variables see {Object.safe_initialization!}
     # - volatile instance variables see {Object.attr_volatile}
     # - volatile instance variables see {Object.attr_atomic}
-    class Object < ObjectImplementation
+    # @!visibility private
+    class Object < AbstractObject
+      include Volatile
+
       # TODO make it a module if possible
 
       # @!method self.attr_volatile(*names)
@@ -38,36 +30,12 @@ module Concurrent
         __initialize_atomic_fields__
       end
 
-      # By calling this method on a class, it and all its children are marked to be constructed safely. Meaning that
-      # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
-      # same behaviour as Java's final fields.
-      # @example
-      #   class AClass < Concurrent::Synchronization::Object
-      #     safe_initialization!
-      #
-      #     def initialize
-      #       @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
-          object.full_memory_barrier if object
-        end
-
-        @safe_initialization = true
+        extend SafeInitialization unless safe_initialization?
       end
 
-      # @return [true, false] if this class is safely initialized.
       def self.safe_initialization?
-        @safe_initialization = false unless defined? @safe_initialization
-        @safe_initialization || (superclass.respond_to?(:safe_initialization?) && superclass.safe_initialization?)
+        self.singleton_class < SafeInitialization
       end
 
       # For testing purposes, quite slow. Injects assert code to new method which will raise if class instance contains

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

@@ -0,0 +1,36 @@
+require 'concurrent/synchronization/full_memory_barrier'
+
+module Concurrent
+  module Synchronization
+
+    # @!visibility private
+    # @!macro internal_implementation_note
+    #
+    # By extending this module, a class and all its children are marked to be constructed safely. Meaning that
+    # all writes (ivar initializations) are made visible to all readers of newly constructed object. It ensures
+    # same behaviour as Java's final fields.
+    #
+    # Due to using Kernel#extend, the module is not included again if already present in the ancestors,
+    # which avoids extra overhead.
+    #
+    # @example
+    #   class AClass < Concurrent::Synchronization::Object
+    #     extend Concurrent::Synchronization::SafeInitialization
+    #
+    #     def initialize
+    #       @AFinalValue = 'value' # published safely, #foo will never return nil
+    #     end
+    #
+    #     def foo
+    #       @AFinalValue
+    #     end
+    #   end
+    module SafeInitialization
+      def new(*args, &block)
+        super(*args, &block)
+      ensure
+        Concurrent::Synchronization.full_memory_barrier
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+require 'concurrent/utility/engine'
+require 'concurrent/synchronization/full_memory_barrier'
+
+module Concurrent
+  module Synchronization
+
+    # Volatile adds the attr_volatile class method when included.
+    #
+    # @example
+    #   class Foo
+    #     include Concurrent::Synchronization::Volatile
+    #
+    #     attr_volatile :bar
+    #
+    #     def initialize
+    #       self.bar = 1
+    #     end
+    #   end
+    #
+    #  foo = Foo.new
+    #  foo.bar
+    #  => 1
+    #  foo.bar = 2
+    #  => 2
+    #
+    # @!visibility private
+    module Volatile
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def full_memory_barrier
+        Synchronization.full_memory_barrier
+      end
+
+      module ClassMethods
+        if Concurrent.on_cruby?
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  #{ivar}
+                end
+
+                def #{name}=(value)
+                  #{ivar} = value
+                end
+              RUBY
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+
+        elsif Concurrent.on_jruby?
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  ::Concurrent::Synchronization::JRubyAttrVolatile.instance_variable_get_volatile(self, :#{ivar})
+                end
+
+                def #{name}=(value)
+                  ::Concurrent::Synchronization::JRubyAttrVolatile.instance_variable_set_volatile(self, :#{ivar}, value)
+                end
+              RUBY
+
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+
+        else
+          warn 'Possibly unsupported Ruby implementation' unless Concurrent.on_truffleruby?
+
+          def attr_volatile(*names)
+            names.each do |name|
+              ivar = :"@volatile_#{name}"
+
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  ::Concurrent::Synchronization.full_memory_barrier
+                  #{ivar}
+                end
+
+                def #{name}=(value)
+                  #{ivar} = value
+                  ::Concurrent::Synchronization.full_memory_barrier
+                end
+              RUBY
+            end
+
+            names.map { |n| [n, :"#{n}="] }.flatten
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require 'concurrent/utility/native_extension_loader' # load native parts first
+
+require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/lockable_object'
+require 'concurrent/synchronization/condition'
+require 'concurrent/synchronization/lock'
+
+module Concurrent
+  # @!visibility private
+  module Synchronization
+  end
+end
+

data/lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb

@@ -0,0 +1,47 @@
+require 'delegate'
+require 'monitor'
+
+module Concurrent
+  # This class provides a trivial way to synchronize all calls to a given object
+  # by wrapping it with a `Delegator` that performs `Monitor#enter/exit` calls
+  # around the delegated `#send`. Example:
+  #
+  #   array = [] # not thread-safe on many impls
+  #   array = SynchronizedDelegator.new([]) # thread-safe
+  #
+  # A simple `Monitor` provides a very coarse-grained way to synchronize a given
+  # object, in that it will cause synchronization for methods that have no need
+  # for it, but this is a trivial way to get thread-safety where none may exist
+  # currently on some implementations.
+  #
+  # This class is currently being considered for inclusion into stdlib, via
+  # https://bugs.ruby-lang.org/issues/8556
+  #
+  # @!visibility private
+  class SynchronizedDelegator < SimpleDelegator
+    def setup
+      @old_abort = Thread.abort_on_exception
+      Thread.abort_on_exception = true
+    end
+
+    def teardown
+      Thread.abort_on_exception = @old_abort
+    end
+
+    def initialize(obj)
+      __setobj__(obj)
+      @monitor = Monitor.new
+    end
+
+    def method_missing(method, *args, &block)
+      monitor = @monitor
+      begin
+        monitor.enter
+        super
+      ensure
+        monitor.exit
+      end
+    end
+
+  end
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/thread_safe/util/cheap_lockable.rb

@@ -1,5 +1,6 @@
 require 'concurrent/thread_safe/util'
 require 'concurrent/thread_safe/util/volatile'
+require 'concurrent/utility/engine'
 
 module Concurrent
 
@@ -32,45 +33,7 @@ module Concurrent
       # @!visibility private
       module CheapLockable
         private
-        engine = defined?(RUBY_ENGINE) && RUBY_ENGINE
-        if engine == 'rbx'
-          # Making use of the Rubinius' ability to lock via object headers to avoid the overhead of the extra Mutex objects.
-          def cheap_synchronize
-            Rubinius.lock(self)
-            begin
-              yield
-            ensure
-              Rubinius.unlock(self)
-            end
-          end
-
-          def cheap_wait
-            wchan = Rubinius::Channel.new
-
-            begin
-              waiters = @waiters ||= []
-              waiters.push wchan
-              Rubinius.unlock(self)
-              signaled = wchan.receive_timeout nil
-            ensure
-              Rubinius.lock(self)
-
-              unless signaled or waiters.delete(wchan)
-                # we timed out, but got signaled afterwards (e.g. while waiting to
-                # acquire @lock), so pass that signal on to the next waiter
-                waiters.shift << true unless waiters.empty?
-              end
-            end
-
-            self
-          end
-
-          def cheap_broadcast
-            waiters = @waiters ||= []
-            waiters.shift << true until waiters.empty?
-            self
-          end
-        elsif engine == 'jruby'
+        if Concurrent.on_jruby?
           # Use Java's native synchronized (this) { wait(); notifyAll(); } to avoid the overhead of the extra Mutex objects
           require 'jruby'