concurrent-ruby 0.8.0.pre2-java → 0.9.0-java

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -1,4 +1,5 @@
-require_relative '../../extension_helper'
+require 'concurrent/utility/native_extension_loader'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -21,7 +22,10 @@ module Concurrent
   #         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
-  class MutexAtomicFixnum
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class MutexAtomicFixnum < Synchronization::Object
 
     # http://stackoverflow.com/questions/535721/ruby-max-integer
     MIN_VALUE = -(2**(0.size * 8 - 2))
@@ -31,12 +35,11 @@ module Concurrent
     #
     #   Creates a new `AtomicFixnum` with the given initial value.
     #
-    #   @param [Fixnum] init the initial value
+    #   @param [Fixnum] initial the initial value
     #   @raise [ArgumentError] if the initial value is not a `Fixnum`
-    def initialize(init = 0)
-      raise ArgumentError.new('initial value must be a Fixnum') unless init.is_a?(Fixnum)
-      @value = init
-      @mutex = Mutex.new
+    def initialize(initial = 0)
+      super()
+      synchronize { ns_initialize(initial) }
     end
 
     # @!macro [attach] atomic_fixnum_method_value_get
@@ -45,10 +48,7 @@ module Concurrent
     #
     #   @return [Fixnum] the current value
     def value
-      @mutex.lock
-      @value
-    ensure
-      @mutex.unlock
+      synchronize { @value }
     end
 
     # @!macro [attach] atomic_fixnum_method_value_set
@@ -61,11 +61,7 @@ module Concurrent
     #
     #   @raise [ArgumentError] if the new value is not a `Fixnum`
     def value=(value)
-      raise ArgumentError.new('value must be a Fixnum') unless value.is_a?(Fixnum)
-      @mutex.lock
-      @value = value
-    ensure
-      @mutex.unlock
+      synchronize { ns_set(value) }
     end
 
     # @!macro [attach] atomic_fixnum_method_increment
@@ -74,10 +70,7 @@ module Concurrent
     #
     #   @return [Fixnum] the current value after incrementation
     def increment
-      @mutex.lock
-      @value += 1
-    ensure
-      @mutex.unlock
+      synchronize { ns_set(@value + 1) }
     end
 
     alias_method :up, :increment
@@ -88,115 +81,94 @@ module Concurrent
     #
     #   @return [Fixnum] the current value after decrementation
     def decrement
-      @mutex.lock
-      @value -= 1
-    ensure
-      @mutex.unlock
+      synchronize { ns_set(@value -1) }
     end
 
     alias_method :down, :decrement
 
     # @!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 [Boolean] true if the value was updated else false 
+    #   @return [Fixnum] true if the value was updated else false
     def compare_and_set(expect, update)
-      @mutex.lock
-      if @value == expect
-        @value = update
-        true
-      else
-        false
+      synchronize do
+        if @value == expect
+          @value = update
+          true
+        else
+          false
+        end
       end
-    ensure
-      @mutex.unlock
     end
-  end
-
-  if RUBY_PLATFORM == 'java'
-
-    # @!macro atomic_fixnum
-    class JavaAtomicFixnum
 
-      MIN_VALUE = Java::JavaLang::Long::MIN_VALUE
-      MAX_VALUE = Java::JavaLang::Long::MAX_VALUE
+    protected
 
-      # @!macro atomic_fixnum_method_initialize
-      def initialize(init = 0)
-        raise ArgumentError.new('initial value must be a Fixnum') unless init.is_a?(Fixnum)
-        @atomic = java.util.concurrent.atomic.AtomicLong.new(init)
-      end
-
-      # @!macro atomic_fixnum_method_value_get
-      def value
-        @atomic.get
-      end
-
-      # @!macro atomic_fixnum_method_value_set
-      def value=(value)
-        raise ArgumentError.new('value must be a Fixnum') unless value.is_a?(Fixnum)
-        @atomic.set(value)
-      end
-
-      # @!macro atomic_fixnum_method_increment
-      def increment
-        @atomic.increment_and_get
-      end
-      alias_method :up, :increment
+    # @!visibility private
+    def ns_initialize(initial)
+      ns_set(initial)
+    end
 
-      # @!macro atomic_fixnum_method_decrement
-      def decrement
-        @atomic.decrement_and_get
-      end
-      alias_method :down, :decrement
+    private
 
-      # @!macro atomic_fixnum_method_compare_and_set
-      def compare_and_set(expect, update)
-        @atomic.compare_and_set(expect, update)
-      end
+    # @!visibility private
+    def ns_set(value)
+      range_check!(value)
+      @value = value
     end
 
-    # @!macro atomic_fixnum
-    class AtomicFixnum < JavaAtomicFixnum
+    # @!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
 
-  elsif defined?(CAtomicFixnum)
-
-    # @!macro atomic_fixnum
-    class CAtomicFixnum
+  # @!visibility private
+  # @!macro internal_implementation_note
+  AtomicFixnumImplementation = case
+                               when Concurrent.on_jruby?
+                                 JavaAtomicFixnum
+                               when defined?(CAtomicFixnum)
+                                 CAtomicFixnum
+                               else
+                                 MutexAtomicFixnum
+                               end
+  private_constant :AtomicFixnumImplementation
+
+  # @!macro atomic_fixnum
+  #
+  # @see Concurrent::MutexAtomicFixnum
+  class AtomicFixnum < AtomicFixnumImplementation
 
-      # @!method initialize
-      #   @!macro atomic_fixnum_method_initialize
+    # @!method initialize(initial = 0)
+    #   @!macro atomic_fixnum_method_initialize
 
-      # @!method value
-      #   @!macro atomic_fixnum_method_value_get
+    # @!method value
+    #   @!macro atomic_fixnum_method_value_get
 
-      # @!method value=
-      #   @!macro atomic_fixnum_method_value_set
+    # @!method value=(value)
+    #   @!macro atomic_fixnum_method_value_set
 
-      # @!method increment
-      #   @!macro atomic_fixnum_method_increment
+    # @!method increment
+    #   @!macro atomic_fixnum_method_increment
 
-      # @!method decrement
-      #   @!macro atomic_fixnum_method_decrement
+    # @!method decrement
+    #   @!macro atomic_fixnum_method_decrement
 
-      # @!method compare_and_set
-      #   @!macro atomic_fixnum_method_compare_and_set
-    end
+    # @!method compare_and_set(expect, update)
+    #   @!macro atomic_fixnum_method_compare_and_set
 
-    # @!macro atomic_fixnum
-    class AtomicFixnum < CAtomicFixnum
-    end
-
-  else
-
-    # @!macro atomic_fixnum
-    class AtomicFixnum < MutexAtomicFixnum
-    end
   end
 end

data/lib/concurrent/atomic/atomic_reference.rb

@@ -0,0 +1,49 @@
+require 'concurrent/utility/native_extension_loader'
+require 'concurrent/utility/engine'
+require 'concurrent/atomic_reference/concurrent_update_error'
+require 'concurrent/atomic_reference/mutex_atomic'
+
+begin
+  # force fallback impl with FORCE_ATOMIC_FALLBACK=1
+  if /[^0fF]/ =~ ENV['FORCE_ATOMIC_FALLBACK']
+    ruby_engine = 'mutex_atomic'
+  else
+    ruby_engine = Concurrent.ruby_engine
+  end
+
+  require "concurrent/atomic_reference/#{ruby_engine}"
+rescue LoadError
+  #warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
+end
+
+if defined? Concurrent::JavaAtomicReference
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::JavaAtomicReference
+  end
+
+elsif defined? Concurrent::RbxAtomicReference
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::RbxAtomicReference
+  end
+
+elsif defined? Concurrent::CAtomicReference
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::CAtomicReference
+  end
+
+else
+
+  # @!macro atomic_reference
+  class Concurrent::AtomicReference < Concurrent::MutexAtomicReference
+  end
+end
+
+module Concurrent
+
+  # @see Concurrent::AtomicReference
+  # @deprecated Use Concurrent::AtomicReference instead.
+  Atomic = AtomicReference
+end

data/lib/concurrent/atomic/condition.rb

@@ -1,14 +1,21 @@
+require 'concurrent/utility/monotonic_time'
+require 'concurrent/concern/deprecation'
+
 module Concurrent
 
-  # Condition is a better implementation of standard Ruby ConditionVariable.
-  # The biggest difference is the wait return value: Condition#wait returns
-  # Condition::Result which make possible to know if waiting thread has been woken up
-  # by an another thread (using #signal or #broadcast) or due to timeout.
+  # Condition is a better implementation of standard Ruby ConditionVariable. The
+  # biggest difference is the wait return value: Condition#wait returns
+  # Condition::Result which make possible to know if waiting thread has been
+  # woken up by an another thread (using #signal or #broadcast) or due to
+  # timeout.
+  #
+  # Every #wait must be guarded by a locked Mutex or a ThreadError will be
+  # risen. Although it's not mandatory, it's recommended to call also #signal
+  # and #broadcast within the same mutex
   #
-  # Every #wait must be guarded by a locked Mutex or a ThreadError will be risen.
-  # Although it's not mandatory, it's recommended to call also #signal and #broadcast within
-  # the same mutex
+  # @deprecated
   class Condition
+    include Concern::Deprecation
 
     class Result
       def initialize(remaining_time)
@@ -17,12 +24,14 @@ module Concurrent
 
       attr_reader :remaining_time
 
-      # @return [Boolean] true if current thread has been waken up by a #signal or a #broadcast call, otherwise false
+      # @return [Boolean] true if current thread has been waken up by a #signal
+      #  or a #broadcast call , otherwise false
       def woken_up?
         @remaining_time.nil? || @remaining_time > 0
       end
 
-      # @return [Boolean] true if current thread has been waken up due to a timeout, otherwise false
+      # @return [Boolean] true if current thread has been waken up due to a
+      #   timeout, otherwise false
       def timed_out?
         @remaining_time != nil && @remaining_time <= 0
       end
@@ -32,20 +41,23 @@ module Concurrent
     end
 
     def initialize
+      deprecated 'Will be replaced with Synchronization::Object in v1.0.'
       @condition = ConditionVariable.new
     end
 
     # @param [Mutex] mutex the locked mutex guarding the wait
     # @param [Object] timeout nil means no timeout
     # @return [Result]
+    #
+    # @!macro monotonic_clock_warning
     def wait(mutex, timeout = nil)
-      start_time = Time.now.to_f
+      start_time = Concurrent.monotonic_time
       @condition.wait(mutex, timeout)
 
       if timeout.nil?
         Result.new(nil)
       else
-        Result.new(start_time + timeout - Time.now.to_f)
+        Result.new(start_time + timeout - Concurrent.monotonic_time)
       end
     end
 
@@ -62,6 +74,5 @@ module Concurrent
       @condition.broadcast
       true
     end
-
   end
 end

data/lib/concurrent/atomic/count_down_latch.rb

@@ -1,4 +1,4 @@
-require 'concurrent/atomic/condition'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -11,7 +11,10 @@ module Concurrent
   #   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.
-  class MutexCountDownLatch
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class PureCountDownLatch < Synchronization::Object
 
     # @!macro [attach] count_down_latch_method_initialize
     #
@@ -20,13 +23,12 @@ module Concurrent
     #   @param [Fixnum] count the initial count
     #
     #   @raise [ArgumentError] if `count` is not an integer or is less than zero
-    def initialize(count)
+    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
-      @mutex = Mutex.new
-      @condition = Condition.new
-      @count = count
+      super()
+      synchronize { ns_initialize count }
     end
 
     # @!macro [attach] count_down_latch_method_wait
@@ -37,15 +39,7 @@ module Concurrent
     #     to block indefinitely
     #   @return [Boolean] `true` if the `count` reaches zero else false on `timeout`
     def wait(timeout = nil)
-      @mutex.synchronize do
-
-        remaining = Condition::Result.new(timeout)
-        while @count > 0 && remaining.can_wait?
-          remaining = @condition.wait(@mutex, remaining.remaining_time)
-        end
-
-        @count == 0
-      end
+      synchronize { ns_wait_until(timeout) { @count == 0 } }
     end
 
     # @!macro [attach] count_down_latch_method_count_down
@@ -53,9 +47,9 @@ module Concurrent
     #   Signal the latch to decrement the counter. Will signal all blocked threads when
     #   the `count` reaches zero.
     def count_down
-      @mutex.synchronize do
+      synchronize do
         @count -= 1 if @count > 0
-        @condition.broadcast if @count == 0
+        ns_broadcast if @count == 0
       end
     end
 
@@ -65,17 +59,25 @@ module Concurrent
     #
     #   @return [Fixnum] the current value of the counter
     def count
-      @mutex.synchronize { @count }
+      synchronize { @count }
+    end
+
+    protected
+
+    def ns_initialize(count)
+      @count = count
     end
   end
 
-  if RUBY_PLATFORM == 'java'
+  if Concurrent.on_jruby?
 
     # @!macro count_down_latch
+    # @!visibility private
+    # @!macro internal_implementation_note
     class JavaCountDownLatch
 
       # @!macro count_down_latch_method_initialize
-      def initialize(count)
+      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
@@ -110,7 +112,7 @@ module Concurrent
   else
 
     # @!macro count_down_latch
-    class CountDownLatch < MutexCountDownLatch
+    class CountDownLatch < PureCountDownLatch
     end
   end
 end