Merge pull request #121 from ruby-concurrency/refactor/executors

Refactor executors

Author: jdantonio

lib/concurrent/atomic_reference/mutex_atomic.rb

@@ -17,33 +17,33 @@ def initialize(value = nil)
 
     # @!macro [attach] atomic_reference_method_get
     #
-    # Gets the current value.
+    #   Gets the current value.
     #
-    # @return [Object] the current value
+    #   @return [Object] the current value
     def get
       @mutex.synchronize { @value }
     end
     alias_method :value, :get
 
     # @!macro [attach] atomic_reference_method_set
     #
-    # Sets to the given value.
+    #   Sets to the given value.
     #
-    # @param [Object] new_value the new value
+    #   @param [Object] new_value the new value
     #
-    # @return [Object] the new value
+    #   @return [Object] the new value
     def set(new_value)
       @mutex.synchronize { @value = new_value }
     end
     alias_method :value=, :set
 
     # @!macro [attach] atomic_reference_method_get_and_set
     #
-    # Atomically sets to the given value and returns the old value.
+    #   Atomically sets to the given value and returns the old value.
     #
-    # @param [Object] new_value the new value
+    #   @param [Object] new_value the new value
     #
-    # @return [Object] the old value
+    #   @return [Object] the old value
     def get_and_set(new_value)
       @mutex.synchronize do
         old_value = @value
@@ -55,14 +55,14 @@ def get_and_set(new_value)
 
     # @!macro [attach] atomic_reference_method_compare_and_set
     #
-    # Atomically sets the value to the given updated value if
-    # the current value == the expected value.
+    #   Atomically sets the value to the given updated value if
+    #   the current value == the expected value.
     #
-    # @param [Object] old_value the expected value
-    # @param [Object] new_value the new value
+    #   @param [Object] old_value the expected value
+    #   @param [Object] new_value the new value
     #
-    # @return [Boolean] `true` if successful. A `false` return indicates
-    # that the actual value was not equal to the expected value.
+    #   @return [Boolean] `true` if successful. A `false` return indicates
+    #   that the actual value was not equal to the expected value.
     def _compare_and_set(old_value, new_value) #:nodoc:
       return false unless @mutex.try_lock
       begin

lib/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -4,20 +4,20 @@ module Concurrent
   module AtomicNumericCompareAndSetWrapper
 
     # @!macro atomic_reference_method_compare_and_set
-    def compare_and_set(expected, new)
-      if expected.kind_of? Numeric
+    def compare_and_set(old_value, new_value)
+      if old_value.kind_of? Numeric
         while true
           old = get
 
           return false unless old.kind_of? Numeric
 
-          return false unless old == expected
+          return false unless old == old_value
 
-          result = _compare_and_set(old, new)
+          result = _compare_and_set(old, new_value)
           return result if result
         end
       else
-        _compare_and_set(expected, new)
+        _compare_and_set(old_value, new_value)
       end
     end
     alias_method :compare_and_swap, :compare_and_set