concurrent-ruby 0.8.0 → 0.9.0.pre2

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

data/lib/concurrent/atomic/cyclic_barrier.rb

@@ -1,42 +1,48 @@
+require 'concurrent/synchronization'
+
 module Concurrent
 
-  class CyclicBarrier
+  class CyclicBarrier < Synchronization::Object
 
+    # @!visibility private
     Generation = Struct.new(:status)
     private_constant :Generation
 
     # Create a new `CyclicBarrier` that waits for `parties` threads
     #
     # @param [Fixnum] parties the number of parties
-    # @yield an optional block that will be executed that will be executed after the last thread arrives and before the others are released
+    # @yield an optional block that will be executed that will be executed after
+    #  the last thread arrives and before the others are released
     #
     # @raise [ArgumentError] if `parties` is not an integer or is less than zero
     def initialize(parties, &block)
-      raise ArgumentError.new('count must be in integer greater than or equal zero') if !parties.is_a?(Fixnum) || parties < 1
-      @parties = parties
-      @mutex = Mutex.new
-      @condition = Condition.new
-      @number_waiting = 0
-      @action = block
-      @generation = Generation.new(:waiting)
+      if !parties.is_a?(Fixnum) || parties < 1
+        raise ArgumentError.new('count must be in integer greater than or equal zero')
+      end
+      super(&nil)
+      synchronize { ns_initialize parties, &block }
     end
 
     # @return [Fixnum] the number of threads needed to pass the barrier
     def parties
-      @parties
+      synchronize { @parties }
     end
 
     # @return [Fixnum] the number of threads currently waiting on the barrier
     def number_waiting
-      @number_waiting
+      synchronize { @number_waiting }
     end
 
-    # Blocks on the barrier until the number of waiting threads is equal to `parties` or until `timeout` is reached or `reset` is called
-    # If a block has been passed to the constructor, it will be executed once by the last arrived thread before releasing the others
-    # @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` or on `reset` or if the barrier is broken
+    # Blocks on the barrier until the number of waiting threads is equal to
+    # `parties` or until `timeout` is reached or `reset` is called
+    # If a block has been passed to the constructor, it will be executed once by
+    #  the last arrived thread before releasing the others
+    # @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` or on `reset` or if the barrier is broken
     def wait(timeout = nil)
-      @mutex.synchronize do
+      synchronize do
 
         return false unless @generation.status == :waiting
 
@@ -44,25 +50,28 @@ module Concurrent
 
         if @number_waiting == @parties
           @action.call if @action
-          set_status_and_restore(:fulfilled)
+          ns_generation_done @generation, :fulfilled
           true
         else
-          wait_for_wake_up(@generation, timeout)
+          generation = @generation
+          if ns_wait_until(timeout) { generation.status != :waiting }
+            generation.status == :fulfilled
+          else
+            ns_generation_done generation, :broken, false
+            false
+          end
         end
       end
     end
 
-
-
     # resets the barrier to its initial state
-    # If there is at least one waiting thread, it will be woken up, the `wait` method will return false and the barrier will be broken
+    # If there is at least one waiting thread, it will be woken up, the `wait`
+    # method will return false and the barrier will be broken
     # If the barrier is broken, this method restores it to the original state
     #
     # @return [nil]
     def reset
-      @mutex.synchronize do
-        set_status_and_restore(:reset)
-      end
+      synchronize { ns_generation_done @generation, :reset }
     end
 
     # A barrier can be broken when:
@@ -72,35 +81,26 @@ module Concurrent
     # A broken barrier can be restored using `reset` it's safer to create a new one
     # @return [Boolean] true if the barrier is broken otherwise false
     def broken?
-      @mutex.synchronize { @generation.status != :waiting }
+      synchronize { @generation.status != :waiting }
     end
 
-    private
+    protected
 
-    def set_status_and_restore(new_status)
-      @generation.status = new_status
-      @condition.broadcast
-      @generation = Generation.new(:waiting)
-      @number_waiting = 0
+    def ns_generation_done(generation, status, continue = true)
+      generation.status = status
+      ns_next_generation if continue
+      ns_broadcast
     end
 
-    def wait_for_wake_up(generation, timeout)
-      if wait_while_waiting(generation, timeout)
-        generation.status == :fulfilled
-      else
-        generation.status = :broken
-        @condition.broadcast
-        false
-      end
+    def ns_next_generation
+      @generation     = Generation.new(:waiting)
+      @number_waiting = 0
     end
 
-    def wait_while_waiting(generation, timeout)
-      remaining = Condition::Result.new(timeout)
-      while generation.status == :waiting && remaining.can_wait?
-        remaining = @condition.wait(@mutex, remaining.remaining_time)
-      end
-      remaining.woken_up?
+    def ns_initialize(parties, &block)
+      @parties = parties
+      @action  = block
+      ns_next_generation
     end
-
   end
-end
+end

data/lib/concurrent/atomic/event.rb

@@ -1,5 +1,5 @@
 require 'thread'
-require 'concurrent/atomic/condition'
+require 'concurrent/synchronization'
 
 module Concurrent
 
@@ -13,24 +13,20 @@ module Concurrent
   # `#reset` at any time once it has been set.
   #
   # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
-  class Event
+  class Event < Synchronization::Object
 
     # Creates a new `Event` in the unset state. Threads calling `#wait` on the
     # `Event` will block.
     def initialize
-      @set = false
-      @mutex = Mutex.new
-      @condition = Condition.new
+      super
+      synchronize { ns_initialize }
     end
 
     # Is the object in the set state?
     #
     # @return [Boolean] indicating whether or not the `Event` has been set
     def set?
-      @mutex.lock
-      @set
-    ensure
-      @mutex.unlock
+      synchronize { @set }
     end
 
     # Trigger the event, setting the state to `set` and releasing all threads
@@ -38,29 +34,11 @@ module Concurrent
     #
     # @return [Boolean] should always return `true`
     def set
-      @mutex.lock
-      unless @set
-        @set = true
-        @condition.broadcast
-      end
-      true
-    ensure
-      @mutex.unlock
+      synchronize { ns_set }
     end
 
     def try?
-      @mutex.lock
-
-      if @set
-        false
-      else
-        @set = true
-        @condition.broadcast
-        true
-      end
-
-    ensure
-      @mutex.unlock
+      synchronize { @set ? false : ns_set }
     end
 
     # Reset a previously set event back to the `unset` state.
@@ -68,11 +46,13 @@ module Concurrent
     #
     # @return [Boolean] should always return `true`
     def reset
-      @mutex.lock
-      @set = false
-      true
-    ensure
-      @mutex.unlock
+      synchronize do
+        if @set
+          @set       = false
+          @iteration +=1
+        end
+        true
+      end
     end
 
     # Wait a given number of seconds for the `Event` to be set by another
@@ -81,18 +61,29 @@ module Concurrent
     #
     # @return [Boolean] true if the `Event` was set before timeout else false
     def wait(timeout = nil)
-      @mutex.lock
+      synchronize do
+        unless @set
+          iteration = @iteration
+          ns_wait_until(timeout) { iteration < @iteration || @set }
+        else
+          true
+        end
+      end
+    end
 
+    protected
+
+    def ns_set
       unless @set
-        remaining = Condition::Result.new(timeout)
-        while !@set && remaining.can_wait?
-          remaining = @condition.wait(@mutex, remaining.remaining_time)
-        end
+        @set = true
+        ns_broadcast
       end
+      true
+    end
 
-      @set
-    ensure
-      @mutex.unlock
+    def ns_initialize
+      @set       = false
+      @iteration = 0
     end
   end
 end