concurrent-ruby 1.0.0.pre4 → 1.0.0.pre5

data/lib/concurrent/delay.rb

@@ -155,7 +155,7 @@ module Concurrent
     protected
 
     def ns_initialize(opts, &block)
-      init_obligation(self)
+      init_obligation
       set_deref_options(opts)
       @executor = opts[:executor]
 

data/lib/concurrent/exchanger.rb

@@ -38,7 +38,7 @@ module Concurrent
   #     threads.each {|t| t.join(2) }
   #
   # @!visibility private
-  class AbstractExchanger
+  class AbstractExchanger < Synchronization::Object
 
     # @!visibility private
     CANCEL = Object.new
@@ -46,7 +46,7 @@ module Concurrent
 
     # @!macro [attach] exchanger_method_initialize
     def initialize
-      raise NotImplementedError
+      super
     end
 
     # @!macro [attach] exchanger_method_do_exchange
@@ -140,24 +140,38 @@ module Concurrent
     # not include the arena or the multi-processor spin loops.
     # http://grepcode.com/file/repository.grepcode.com/java/root/jdk/openjdk/6-b14/java/util/concurrent/Exchanger.java
 
-    # @!visibility private
-    class Node < Concurrent::AtomicReference
-      attr_reader :item, :latch
+    safe_initialization!
+
+    class Node < Concurrent::Synchronization::Object
+      attr_volatile_with_cas :value
+      safe_initialization!
+
       def initialize(item)
-        @item = item
-        @latch = Concurrent::CountDownLatch.new
-        super(nil)
+        super()
+        @Item = item
+        @Latch = Concurrent::CountDownLatch.new
+        self.value = nil
+      end
+
+      def latch
+        @Latch
+      end
+
+      def item
+        @Item
       end
     end
     private_constant :Node
 
     # @!macro exchanger_method_initialize
     def initialize
-      @slot = Concurrent::AtomicReference.new
+      super
     end
 
     private
 
+    attr_volatile_with_cas(:slot)
+
     # @!macro exchanger_method_do_exchange
     #
     # @return [Object, CANCEL] the value exchanged by the other thread; {CANCEL} on timeout
@@ -247,20 +261,19 @@ module Concurrent
       #     - Return the occupier's item
 
       value = NULL if value.nil?                        # The sentinel allows nil to be a valid value
-      slot = @slot                                      # Convenience to minimize typing @
       me = Node.new(value)                              # create my node in case I need to occupy
       end_at = Concurrent.monotonic_time + timeout.to_f # The time to give up
 
       result = loop do
-        other = slot.get
-        if other && slot.compare_and_set(other, nil)
+        other = slot
+        if other && compare_and_set_slot(other, nil)
           # try to fulfill
-          if other.compare_and_set(nil, value)
+          if other.compare_and_set_value(nil, value)
             # happy path
             other.latch.count_down
             break other.item
           end
-        elsif other.nil? && slot.compare_and_set(nil, me)
+        elsif other.nil? && compare_and_set_slot(nil, me)
           # try to occupy
           timeout = end_at - Concurrent.monotonic_time if timeout
           if me.latch.wait(timeout)
@@ -268,11 +281,11 @@ module Concurrent
             break me.value
           else
             # attempt to remove myself from the slot
-            if slot.compare_and_set(me, nil)
+            if compare_and_set_slot(me, nil)
               break CANCEL
-            elsif !me.compare_and_set(nil, CANCEL)
+            elsif !me.compare_and_set_value(nil, CANCEL)
               # I've failed to block the fulfiller
-              break me.get
+              break me.value
             end
           end
         end

data/lib/concurrent/executor/ruby_thread_pool_executor.rb

@@ -101,6 +101,11 @@ module Concurrent
       synchronize { ns_worker_died worker }
     end
 
+    # @!visibility private
+    def worker_task_completed
+      synchronize { @completed_task_count += 1 }
+    end
+
     private
 
     # @!visibility private
@@ -180,7 +185,6 @@ module Concurrent
       worker = (@ready.pop if @pool.size >= @min_length) || ns_add_busy_worker
       if worker
         worker << [task, args]
-        @completed_task_count += 1
         true
       else
         false
@@ -327,6 +331,7 @@ module Concurrent
 
       def run_task(pool, task, args)
         task.call(*args)
+        pool.worker_task_completed
       rescue => ex
         # let it fail
         log DEBUG, ex

data/lib/concurrent/ivar.rb

@@ -153,7 +153,7 @@ module Concurrent
     # @!visibility private
     def ns_initialize(value, opts)
       value = yield if block_given?
-      init_obligation(self)
+      init_obligation
       self.observers = Collection::CopyOnWriteObserverSet.new
       set_deref_options(opts)
 

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_volatile_with_cas(: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

@@ -1,6 +1,6 @@
 require 'thread'
 require 'concurrent/constants'
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 
 module Concurrent
   # @!visibility private

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/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/promise.rb

@@ -304,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,

data/lib/concurrent/synchronization.rb

@@ -2,11 +2,13 @@ require 'concurrent/utility/engine'
 
 require 'concurrent/synchronization/abstract_object'
 require 'concurrent/utility/native_extension_loader' # load native parts first
+Concurrent.load_native_extensions
 
 require 'concurrent/synchronization/mri_object'
 require 'concurrent/synchronization/jruby_object'
 require 'concurrent/synchronization/rbx_object'
 require 'concurrent/synchronization/object'
+require 'concurrent/synchronization/volatile'
 
 require 'concurrent/synchronization/abstract_lockable_object'
 require 'concurrent/synchronization/mri_lockable_object'
@@ -20,6 +22,7 @@ require 'concurrent/synchronization/lock'
 
 module Concurrent
   # {include:file:doc/synchronization.md}
+  # {include:file:doc/synchronization-notes.md}
   module Synchronization
   end
 end

data/lib/concurrent/synchronization/abstract_lockable_object.rb

@@ -1,6 +1,6 @@
 module Concurrent
   module Synchronization
-    # @!macro synchronization_object
+
     # @!visibility private
     class AbstractLockableObject < Object
 
@@ -15,25 +15,6 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ns_initialize
-      #
-      #   initialization of the object called inside synchronize block
-      #   @note has to be called manually when required in children of this class
-      #   @example
-      #     class Child < Concurrent::Synchornization::Object
-      #       def initialize(*args, &block)
-      #         super(&nil)
-      #         synchronize { ns_initialize(*args, &block) }
-      #       end
-      #
-      #       def ns_initialize(*args, &block)
-      #         @args = args
-      #       end
-      #     end
-      # TODO (pitr 12-Sep-2015): remove
-      def ns_initialize(*args, &block)
-      end
-
       # @!macro [attach] synchronization_object_method_ns_wait_until
       #
       #   Wait until condition is met or timeout passes,

data/lib/concurrent/synchronization/abstract_object.rb

@@ -1,8 +1,8 @@
 module Concurrent
   module Synchronization
 
-    # @!macro synchronization_object
     # @!visibility private
+    # @!macro internal_implementation_note
     class AbstractObject
 
       # @abstract has to be implemented based on Ruby runtime
@@ -10,38 +10,12 @@ module Concurrent
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_ensure_ivar_visibility
-      #
-      #   Allows to construct immutable objects where all fields are visible after initialization, not requiring
-      #   further synchronization on access.
-      #   @example
-      #     class AClass
-      #       attr_reader :val
-      #       def initialize(val)
-      #         @val = val # final value, after assignment it's not changed (just convention, not enforced)
-      #         ensure_ivar_visibility!
-      #         # now it can be shared as Java's final field
-      #       end
-      #     end
-      # @!visibility private
-      def ensure_ivar_visibility!
-        # We have to prevent ivar writes to reordered with storing of the final instance reference
-        # Therefore wee need a fullFence to prevent reordering in both directions.
-        full_memory_barrier
-      end
-
-      protected
-
       # @!visibility private
       # @abstract
       def full_memory_barrier
         raise NotImplementedError
       end
 
-      # @!macro [attach] synchronization_object_method_self_attr_volatile
-      #
-      #   creates methods for reading and writing to a instance variable with volatile (Java semantic) instance variable
-      #   return [Array<Symbol>] names of defined method names
       def self.attr_volatile(*names)
         raise NotImplementedError
       end

data/lib/concurrent/synchronization/jruby_object.rb

@@ -3,33 +3,41 @@ module Concurrent
 
     if Concurrent.on_jruby? && Concurrent.java_extensions_loaded?
 
-      # @!visibility private
-      # @!macro internal_implementation_note
-      class JRubyObject < AbstractObject
-
-        def initialize
-          # nothing to do
+      module JRubyAttrVolatile
+        def self.included(base)
+          base.extend(ClassMethods)
         end
 
-        def self.attr_volatile(*names)
-          names.each do |name|
+        module ClassMethods
+          def attr_volatile(*names)
+            names.each do |name|
 
-            ivar = :"@volatile_#{name}"
+              ivar = :"@volatile_#{name}"
 
-            class_eval <<-RUBY, __FILE__, __LINE__ + 1
-              def #{name}
-                instance_variable_get_volatile(:#{ivar})
-              end
+              class_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{name}
+                  instance_variable_get_volatile(:#{ivar})
+                end
 
-              def #{name}=(value)
-                instance_variable_set_volatile(:#{ivar}, value)
-              end
-            RUBY
+                def #{name}=(value)
+                  instance_variable_set_volatile(:#{ivar}, value)
+                end
+              RUBY
 
+            end
+            names.map { |n| [n, :"#{n}="] }.flatten
           end
-          names.map { |n| [n, :"#{n}="] }.flatten
         end
+      end
 
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JRubyObject < AbstractObject
+        include JRubyAttrVolatile
+
+        def initialize
+          # nothing to do
+        end
       end
     end
   end