concurrent-ruby 0.9.2-java → 1.0.0-java

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -1,165 +1,102 @@
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/atomic/mutex_atomic_fixnum'
 require 'concurrent/synchronization'
 
 module Concurrent
 
-  # @!macro [attach] atomic_fixnum
-  #
-  #   A numeric value that can be updated atomically. Reads and writes to an atomic
-  #   fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
-  #   briefly but no explicit locking is required.
+  ###################################################################
+
+  # @!macro [new] atomic_fixnum_method_initialize
   #
-  #       Testing with ruby 2.1.2
-  #       Testing with Concurrent::MutexAtomicFixnum...
-  #         3.130000   0.000000   3.130000 (  3.136505)
-  #       Testing with Concurrent::CAtomicFixnum...
-  #         0.790000   0.000000   0.790000 (  0.785550)
+  #   Creates a new `AtomicFixnum` with the given initial value.
   #
-  #       Testing with jruby 1.9.3
-  #       Testing with Concurrent::MutexAtomicFixnum...
-  #         5.460000   2.460000   7.920000 (  3.715000)
-  #       Testing with Concurrent::JavaAtomicFixnum...
-  #         4.520000   0.030000   4.550000 (  1.187000)
+  #   @param [Fixnum] initial the initial value
+  #   @raise [ArgumentError] if the initial value is not a `Fixnum`
+
+  # @!macro [new] atomic_fixnum_method_value_get
   #
-  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
+  #   Retrieves the current `Fixnum` value.
   #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class MutexAtomicFixnum < Synchronization::Object
+  #   @return [Fixnum] the current value
 
-    # http://stackoverflow.com/questions/535721/ruby-max-integer
-    MIN_VALUE = -(2**(0.size * 8 - 2))
-    MAX_VALUE = (2**(0.size * 8 - 2) - 1)
-
-    # @!macro [attach] atomic_fixnum_method_initialize
-    #
-    #   Creates a new `AtomicFixnum` with the given initial value.
-    #
-    #   @param [Fixnum] initial the initial value
-    #   @raise [ArgumentError] if the initial value is not a `Fixnum`
-    def initialize(initial = 0)
-      super()
-      synchronize { ns_initialize(initial) }
-    end
-
-    # @!macro [attach] atomic_fixnum_method_value_get
-    #
-    #   Retrieves the current `Fixnum` value.
-    #
-    #   @return [Fixnum] the current value
-    def value
-      synchronize { @value }
-    end
-
-    # @!macro [attach] atomic_fixnum_method_value_set
-    #
-    #   Explicitly sets the value.
-    #
-    #   @param [Fixnum] value the new value to be set
-    #
-    #   @return [Fixnum] the current value
-    #
-    #   @raise [ArgumentError] if the new value is not a `Fixnum`
-    def value=(value)
-      synchronize { ns_set(value) }
-    end
-
-    # @!macro [attach] atomic_fixnum_method_increment
-    #
-    #   Increases the current value by the given amount (defaults to 1).
-    #
-    #   @param [Fixnum] delta the amount by which to increase the current value
-    #
-    #   @return [Fixnum] the current value after incrementation
-    def increment(delta = 1)
-      synchronize { ns_set(@value + delta.to_i) }
-    end
-
-    alias_method :up, :increment
-
-    # @!macro [attach] atomic_fixnum_method_decrement
-    #
-    #   Decreases the current value by the given amount (defaults to 1).
-    #
-    #   @param [Fixnum] delta the amount by which to decrease the current value
-    #
-    #   @return [Fixnum] the current value after decrementation
-    def decrement(delta = 1)
-      synchronize { ns_set(@value - delta.to_i) }
-    end
-
-    alias_method :down, :decrement
+  # @!macro [new] atomic_fixnum_method_value_set
+  #
+  #   Explicitly sets the value.
+  #
+  #   @param [Fixnum] value the new value to be set
+  #
+  #   @return [Fixnum] the current value
+  #
+  #   @raise [ArgumentError] if the new value is not a `Fixnum`
 
-    # @!macro [attach] atomic_fixnum_method_compare_and_set
-    #
-    #   Atomically sets the value to the given updated value if the current
-    #   value == the expected value.
-    #
-    #   @param [Fixnum] expect the expected value
-    #   @param [Fixnum] update the new value
-    #
-    #   @return [Fixnum] true if the value was updated else false
-    def compare_and_set(expect, update)
-      synchronize do
-        if @value == expect.to_i
-          @value = update.to_i
-          true
-        else
-          false
-        end
-      end
-    end
+  # @!macro [new] atomic_fixnum_method_increment
+  #
+  #   Increases the current value by the given amount (defaults to 1).
+  #
+  #   @param [Fixnum] delta the amount by which to increase the current value
+  #
+  #   @return [Fixnum] the current value after incrementation
 
-    # @!macro [attach] atomic_fixnum_method_update
-    #
-    # Pass the current value to the given block, replacing it
-    # with the block's result. May retry if the value changes
-    # during the block's execution.
-    #
-    # @yield [Object] Calculate a new value for the atomic reference using
-    #   given (old) value
-    # @yieldparam [Object] old_value the starting value of the atomic reference
-    #
-    # @return [Object] the new value
-    def update
-      synchronize do
-        @value = yield @value
-      end
-    end
+  # @!macro [new] atomic_fixnum_method_decrement
+  #
+  #   Decreases the current value by the given amount (defaults to 1).
+  #
+  #   @param [Fixnum] delta the amount by which to decrease the current value
+  #
+  #   @return [Fixnum] the current value after decrementation
 
-    protected
+  # @!macro [new] atomic_fixnum_method_compare_and_set
+  #
+  #   Atomically sets the value to the given updated value if the current
+  #   value == the expected value.
+  #
+  #   @param [Fixnum] expect the expected value
+  #   @param [Fixnum] update the new value
+  #
+  #   @return [Fixnum] true if the value was updated else false
 
-    # @!visibility private
-    def ns_initialize(initial)
-      ns_set(initial)
-    end
+  # @!macro [new] atomic_fixnum_method_update
+  #
+  #   Pass the current value to the given block, replacing it
+  #   with the block's result. May retry if the value changes
+  #   during the block's execution.
+  #
+  #   @yield [Object] Calculate a new value for the atomic reference using
+  #     given (old) value
+  #   @yieldparam [Object] old_value the starting value of the atomic reference
+  #
+  #   @return [Object] the new value
 
-    private
+  ###################################################################
 
-    # @!visibility private
-    def ns_set(value)
-      range_check!(value)
-      @value = value
-    end
+  # @!macro [new] atomic_fixnum_public_api
+  #
+  #   @!method initialize(initial = 0)
+  #     @!macro atomic_fixnum_method_initialize
+  #
+  #   @!method value
+  #     @!macro atomic_fixnum_method_value_get
+  #
+  #   @!method value=(value)
+  #     @!macro atomic_fixnum_method_value_set
+  #
+  #   @!method increment
+  #     @!macro atomic_fixnum_method_increment
+  #
+  #   @!method decrement
+  #     @!macro atomic_fixnum_method_decrement
+  #
+  #   @!method compare_and_set(expect, update)
+  #     @!macro atomic_fixnum_method_compare_and_set
+  #
+  #   @!method update
+  #     @!macro atomic_fixnum_method_update
 
-    # @!visibility private
-    def range_check!(value)
-      if !value.is_a?(Fixnum)
-        raise ArgumentError.new('value value must be a Fixnum')
-      elsif value > MAX_VALUE
-        raise RangeError.new("#{value} is greater than the maximum value of #{MAX_VALUE}")
-      elsif value < MIN_VALUE
-        raise RangeError.new("#{value} is less than the maximum value of #{MIN_VALUE}")
-      else
-        value
-      end
-    end
-  end
+  ###################################################################
 
   # @!visibility private
   # @!macro internal_implementation_note
   AtomicFixnumImplementation = case
-                               when Concurrent.on_jruby?
+                               when defined?(JavaAtomicFixnum)
                                  JavaAtomicFixnum
                                when defined?(CAtomicFixnum)
                                  CAtomicFixnum
@@ -168,28 +105,29 @@ module Concurrent
                                end
   private_constant :AtomicFixnumImplementation
 
-  # @!macro atomic_fixnum
+  # @!macro [attach] atomic_fixnum
+  #
+  #   A numeric value that can be updated atomically. Reads and writes to an atomic
+  #   fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
+  #   briefly but no explicit locking is required.
+  #
+  #   @!macro thread_safe_variable_comparison
   #
-  # @see Concurrent::MutexAtomicFixnum
+  #       Testing with ruby 2.1.2
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         3.130000   0.000000   3.130000 (  3.136505)
+  #       Testing with Concurrent::CAtomicFixnum...
+  #         0.790000   0.000000   0.790000 (  0.785550)
+  #
+  #       Testing with jruby 1.9.3
+  #       Testing with Concurrent::MutexAtomicFixnum...
+  #         5.460000   2.460000   7.920000 (  3.715000)
+  #       Testing with Concurrent::JavaAtomicFixnum...
+  #         4.520000   0.030000   4.550000 (  1.187000)
+  #
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
+  #
+  # @!macro atomic_fixnum_public_api
   class AtomicFixnum < AtomicFixnumImplementation
-
-    # @!method initialize(initial = 0)
-    #   @!macro atomic_fixnum_method_initialize
-
-    # @!method value
-    #   @!macro atomic_fixnum_method_value_get
-
-    # @!method value=(value)
-    #   @!macro atomic_fixnum_method_value_set
-
-    # @!method increment
-    #   @!macro atomic_fixnum_method_increment
-
-    # @!method decrement
-    #   @!macro atomic_fixnum_method_decrement
-
-    # @!method compare_and_set(expect, update)
-    #   @!macro atomic_fixnum_method_compare_and_set
-
   end
 end

data/lib/concurrent/atomic/atomic_reference.rb

@@ -1,4 +1,4 @@
-require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 require 'concurrent/utility/engine'
 require 'concurrent/atomic_reference/concurrent_update_error'
 require 'concurrent/atomic_reference/mutex_atomic'
@@ -40,10 +40,3 @@ else
   class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
   end
 end
-
-module Concurrent
-
-  # @see Concurrent::AtomicReference
-  # @deprecated Use Concurrent::AtomicReference instead.
-  Atomic = AtomicReference
-end

data/lib/concurrent/atomic/count_down_latch.rb

@@ -1,118 +1,77 @@
-require 'concurrent/synchronization'
+require 'concurrent/atomic/mutex_count_down_latch'
+require 'concurrent/atomic/java_count_down_latch'
+require 'concurrent/utility/engine'
 
 module Concurrent
 
-  # @!macro [attach] count_down_latch
+  ###################################################################
+
+  # @!macro [new] count_down_latch_method_initialize
   #
-  #   A synchronization object that allows one thread to wait on multiple other threads.
-  #   The thread that will wait creates a `CountDownLatch` and sets the initial value
-  #   (normally equal to the number of other threads). The initiating thread passes the
-  #   latch to the other threads then waits for the other threads by calling the `#wait`
-  #   method. Each of the other threads calls `#count_down` when done with its work.
-  #   When the latch counter reaches zero the waiting thread is unblocked and continues
-  #   with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
+  #   Create a new `CountDownLatch` with the initial `count`.
   #
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class PureCountDownLatch < Synchronization::Object
-
-    # @!macro [attach] count_down_latch_method_initialize
-    #
-    #   Create a new `CountDownLatch` with the initial `count`.
-    #
-    #   @param [Fixnum] count the initial count
-    #
-    #   @raise [ArgumentError] if `count` is not an integer or is less than zero
-    def initialize(count = 1)
-      unless count.is_a?(Fixnum) && count >= 0
-        raise ArgumentError.new('count must be in integer greater than or equal zero')
-      end
-      super()
-      synchronize { ns_initialize count }
-    end
-
-    # @!macro [attach] count_down_latch_method_wait
-    #
-    #   Block on the latch until the counter reaches zero or until `timeout` is reached.
-    #
-    #   @param [Fixnum] timeout the number of seconds to wait for the counter or `nil`
-    #     to block indefinitely
-    #   @return [Boolean] `true` if the `count` reaches zero else false on `timeout`
-    def wait(timeout = nil)
-      synchronize { ns_wait_until(timeout) { @count == 0 } }
-    end
-
-    # @!macro [attach] count_down_latch_method_count_down
-    #
-    #   Signal the latch to decrement the counter. Will signal all blocked threads when
-    #   the `count` reaches zero.
-    def count_down
-      synchronize do
-        @count -= 1 if @count > 0
-        ns_broadcast if @count == 0
-      end
-    end
-
-    # @!macro [attach] count_down_latch_method_count
-    #
-    #   The current value of the counter.
-    #
-    #   @return [Fixnum] the current value of the counter
-    def count
-      synchronize { @count }
-    end
-
-    protected
-
-    def ns_initialize(count)
-      @count = count
-    end
-  end
-
-  if Concurrent.on_jruby?
+  #   @param [new] count the initial count
+  #
+  #   @raise [ArgumentError] if `count` is not an integer or is less than zero
 
-    # @!macro count_down_latch
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class JavaCountDownLatch
+  # @!macro [new] count_down_latch_method_wait
+  #
+  #   Block on the latch until the counter reaches zero or until `timeout` is reached.
+  #
+  #   @param [Fixnum] timeout the number of seconds to wait for the counter or `nil`
+  #     to block indefinitely
+  #   @return [Boolean] `true` if the `count` reaches zero else false on `timeout`
 
-      # @!macro count_down_latch_method_initialize
-      def initialize(count = 1)
-        unless count.is_a?(Fixnum) && count >= 0
-          raise ArgumentError.new('count must be in integer greater than or equal zero')
-        end
-        @latch = java.util.concurrent.CountDownLatch.new(count)
-      end
+  # @!macro [new] count_down_latch_method_count_down
+  #
+  #   Signal the latch to decrement the counter. Will signal all blocked threads when
+  #   the `count` reaches zero.
 
-      # @!macro count_down_latch_method_wait
-      def wait(timeout = nil)
-        if timeout.nil?
-          @latch.await
-          true
-        else
-          @latch.await(1000 * timeout, java.util.concurrent.TimeUnit::MILLISECONDS)
-        end
-      end
+  # @!macro [attach] count_down_latch_method_count
+  #
+  #   The current value of the counter.
+  #
+  #   @return [Fixnum] the current value of the counter
 
-      # @!macro count_down_latch_method_count_down
-      def count_down
-        @latch.countDown
-      end
+  ###################################################################
 
-      # @!macro count_down_latch_method_count
-      def count
-        @latch.getCount
-      end
-    end
+  # @!macro [new] count_down_latch_public_api
+  #
+  #   @!method initialize(count = 1)
+  #     @!macro count_down_latch_method_initialize
+  #
+  #   @!method wait(timeout = nil)
+  #     @!macro count_down_latch_method_wait
+  #
+  #   @!method count_down
+  #     @!macro count_down_latch_method_count_down
+  #
+  #   @!method count
+  #     @!macro count_down_latch_method_count
 
-    # @!macro count_down_latch
-    class CountDownLatch < JavaCountDownLatch
-    end
+  ###################################################################
 
-  else
+  # @!visibility private
+  # @!macro internal_implementation_note
+  CountDownLatchImplementation = case
+                                 when Concurrent.on_jruby?
+                                   JavaCountDownLatch
+                                 else
+                                   MutexCountDownLatch
+                                 end
+  private_constant :CountDownLatchImplementation
 
-    # @!macro count_down_latch
-    class CountDownLatch < PureCountDownLatch
-    end
+  # @!macro [attach] count_down_latch
+  #
+  #   A synchronization object that allows one thread to wait on multiple other threads.
+  #   The thread that will wait creates a `CountDownLatch` and sets the initial value
+  #   (normally equal to the number of other threads). The initiating thread passes the
+  #   latch to the other threads then waits for the other threads by calling the `#wait`
+  #   method. Each of the other threads calls `#count_down` when done with its work.
+  #   When the latch counter reaches zero the waiting thread is unblocked and continues
+  #   with its work. A `CountDownLatch` can be used only once. Its value cannot be reset.
+  #
+  # @!macro count_down_latch_public_api
+  class CountDownLatch < CountDownLatchImplementation
   end
 end