IVar is now a Synchronization::Object.

* Dereferenceable supports injection of a mutex
* Obligation supports injection of a mutex
* IVar extends Synchronization::Object
* IVar passes `self` to Obligation as injected mutex
* IVar, Promise, and Future no longer call `mutex#lock`

Author: jdantonio

lib/concurrent/dereferenceable.rb

@@ -39,24 +39,17 @@ module Dereferenceable
     #
     # @return [Object] the current value of the object
     def value
-      mutex.lock
-      apply_deref_options(@value)
-    ensure
-      mutex.unlock
+      mutex.synchronize { apply_deref_options(@value) }
     end
-
     alias_method :deref, :value
 
     protected
 
     # Set the internal value of this object
     #
     # @param [Object] val the new value
-    def value=(val)
-      mutex.lock
-      @value = val
-    ensure
-      mutex.unlock
+    def value=(value)
+      mutex.synchronize{ @value = value }
     end
 
     # A mutex lock used for synchronizing thread-safe operations. Methods defined
@@ -74,8 +67,8 @@ def mutex
     # @note This method *must* be called from within the constructor of the including class.
     #
     # @see #mutex
-    def init_mutex
-      @mutex = Mutex.new
+    def init_mutex(mutex = Mutex.new)
+      @mutex = mutex
     end
 
     # Set the options which define the operations #value performs before
@@ -91,14 +84,13 @@ def init_mutex
     # @option opts [String] :copy_on_deref (nil) call the given `Proc` passing
     #   the internal value and returning the value returned from the proc
     def set_deref_options(opts = {})
-      mutex.lock
-      @dup_on_deref = opts[:dup_on_deref] || opts[:dup]
-      @freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze]
-      @copy_on_deref = opts[:copy_on_deref] || opts[:copy]
-      @do_nothing_on_deref = !(@dup_on_deref || @freeze_on_deref || @copy_on_deref)
-      nil
-    ensure
-      mutex.unlock
+      mutex.synchronize do
+        @dup_on_deref = opts[:dup_on_deref] || opts[:dup]
+        @freeze_on_deref = opts[:freeze_on_deref] || opts[:freeze]
+        @copy_on_deref = opts[:copy_on_deref] || opts[:copy]
+        @do_nothing_on_deref = !(@dup_on_deref || @freeze_on_deref || @copy_on_deref)
+        nil
+      end
     end
 
     # @!visibility private

lib/concurrent/ivar.rb

@@ -3,6 +3,7 @@
 require 'concurrent/errors'
 require 'concurrent/obligation'
 require 'concurrent/observable'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -38,7 +39,7 @@ module Concurrent
   #   ivar.set 14
   #   ivar.get #=> 14
   #   ivar.set 2 # would now be an error
-  class IVar
+  class IVar < Synchronization::Object
     include Obligation
     include Observable
 
@@ -56,7 +57,8 @@ class IVar
     # @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 = {})
-      init_obligation
+      super(&nil)
+      init_obligation(self)
       self.observers = CopyOnWriteObserverSet.new
       set_deref_options(opts)
       @state = :pending

lib/concurrent/obligation.rb

@@ -113,10 +113,7 @@ def value!(timeout = nil)
     #
     # @return [Symbol] the current state
     def state
-      mutex.lock
-      @state
-    ensure
-      mutex.unlock
+      mutex.synchronize { @state }
     end
 
     # If an exception was raised during processing this will return the
@@ -125,10 +122,7 @@ def state
     #
     # @return [Exception] the exception raised during processing or `nil`
     def reason
-      mutex.lock
-      @reason
-    ensure
-      mutex.unlock
+      mutex.synchronize { @reason }
     end
 
     # @example allows Obligation to be risen
@@ -147,8 +141,8 @@ def get_arguments_from(opts = {}) # :nodoc:
     end
 
     # @!visibility private
-    def init_obligation # :nodoc:
-      init_mutex
+    def init_obligation(*args) # :nodoc:
+      init_mutex(*args)
       @event = Event.new
     end
 
@@ -170,10 +164,7 @@ def set_state(success, value, reason) # :nodoc:
 
     # @!visibility private
     def state=(value) # :nodoc:
-      mutex.lock
-      @state = value
-    ensure
-      mutex.unlock
+      mutex.synchronize { @state = value }
     end
 
     # Atomic compare and set operation
@@ -186,15 +177,14 @@ def state=(value) # :nodoc:
     #
     # @!visibility private
     def compare_and_set_state(next_state, expected_current) # :nodoc:
-      mutex.lock
-      if @state == expected_current
-        @state = next_state
-        true
-      else
-        false
+      mutex.synchronize do
+        if @state == expected_current
+          @state = next_state
+          true
+        else
+          false
+        end
       end
-    ensure
-      mutex.unlock
     end
 
     # executes the block within mutex if current state is included in expected_states
@@ -203,16 +193,15 @@ def compare_and_set_state(next_state, expected_current) # :nodoc:
     #
     # @!visibility private
     def if_state(*expected_states) # :nodoc:
-      mutex.lock
-      raise ArgumentError.new('no block given') unless block_given?
-
-      if expected_states.include? @state
-        yield
-      else
-        false
+      mutex.synchronize do
+        raise ArgumentError.new('no block given') unless block_given?
+
+        if expected_states.include? @state
+          yield
+        else
+          false
+        end
       end
-    ensure
-      mutex.unlock
     end
   end
 end

lib/concurrent/promise.rb

@@ -481,10 +481,7 @@ def set_state!(success, value, reason)
 
     # @!visibility private
     def synchronized_set_state!(success, value, reason)
-      mutex.lock
-      set_state!(success, value, reason)
-    ensure
-      mutex.unlock
+      mutex.synchronize { set_state!(success, value, reason) }
     end
   end
 end