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

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

data/lib/concurrent/atomic/read_write_lock.rb

@@ -0,0 +1,252 @@
+require 'thread'
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/errors'
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  # Ruby read-write lock implementation
+  #
+  # Allows any number of concurrent readers, but only one concurrent writer
+  # (And if the "write" lock is taken, any readers who come along will have to wait)
+  #
+  # If readers are already active when a writer comes along, the writer will wait for
+  # all the readers to finish before going ahead.
+  # Any additional readers that come when the writer is already waiting, will also
+  # wait (so writers are not starved).
+  #
+  # This implementation is based on `java.util.concurrent.ReentrantReadWriteLock`.
+  #
+  # @example
+  #   lock = Concurrent::ReadWriteLock.new
+  #   lock.with_read_lock  { data.retrieve }
+  #   lock.with_write_lock { data.modify! }
+  #
+  # @note Do **not** try to acquire the write lock while already holding a read lock
+  #   **or** try to acquire the write lock while you already have it.
+  #   This will lead to deadlock
+  #
+  # @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/locks/ReentrantReadWriteLock.html java.util.concurrent.ReentrantReadWriteLock
+  class ReadWriteLock < Synchronization::Object
+
+    # @!visibility private
+    WAITING_WRITER = 1 << 15
+
+    # @!visibility private
+    RUNNING_WRITER = 1 << 30
+
+    # @!visibility private
+    MAX_READERS    = WAITING_WRITER - 1
+
+    # @!visibility private
+    MAX_WRITERS    = RUNNING_WRITER - MAX_READERS - 1
+
+    # Implementation notes: 
+    # A goal is to make the uncontended path for both readers/writers lock-free
+    # Only if there is reader-writer or writer-writer contention, should locks be used
+    # Internal state is represented by a single integer ("counter"), and updated 
+    #  using atomic compare-and-swap operations
+    # When the counter is 0, the lock is free
+    # Each reader increments the counter by 1 when acquiring a read lock
+    #   (and decrements by 1 when releasing the read lock)
+    # The counter is increased by (1 << 15) for each writer waiting to acquire the
+    #   write lock, and by (1 << 30) if the write lock is taken
+
+    # Create a new `ReadWriteLock` in the unlocked state.
+    def initialize
+      @Counter   = AtomicReference.new(0) # single integer which represents lock state
+      @ReadLock  = Synchronization::Lock.new
+      @WriteLock = Synchronization::Lock.new
+      ensure_ivar_visibility!
+      super()
+    end
+
+    # Execute a block operation within a read lock.
+    #
+    # @yield the task to be performed within the lock.
+    #
+    # @return [Object] the result of the block operation.
+    #
+    # @raise [ArgumentError] when no block is given.
+    # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+    #   is exceeded.
+    def with_read_lock
+      raise ArgumentError.new('no block given') unless block_given?
+      acquire_read_lock
+      begin
+        yield
+      ensure
+        release_read_lock
+      end
+    end
+
+    # Execute a block operation within a write lock.
+    #
+    # @yield the task to be performed within the lock.
+    #
+    # @return [Object] the result of the block operation.
+    #
+    # @raise [ArgumentError] when no block is given.
+    # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+    #   is exceeded.
+    def with_write_lock
+      raise ArgumentError.new('no block given') unless block_given?
+      acquire_write_lock
+      begin
+        yield
+      ensure
+        release_write_lock
+      end
+    end
+
+    # Acquire a read lock. If a write lock has been acquired will block until
+    # it is released. Will not block if other read locks have been acquired.
+    #
+    # @return [Boolean] true if the lock is successfully acquired
+    #
+    # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
+    #   is exceeded.
+    def acquire_read_lock
+      while true
+        c = @Counter.value
+        raise ResourceLimitError.new('Too many reader threads') if max_readers?(c)
+
+        # If a writer is waiting when we first queue up, we need to wait
+        if waiting_writer?(c)
+          @ReadLock.wait_until { !waiting_writer? }
+
+          # after a reader has waited once, they are allowed to "barge" ahead of waiting writers
+          # but if a writer is *running*, the reader still needs to wait (naturally)
+          while true
+            c = @Counter.value
+            if running_writer?(c)
+              @ReadLock.wait_until { !running_writer? }
+            else
+              return if @Counter.compare_and_swap(c, c+1)
+            end
+          end
+        else
+          break if @Counter.compare_and_swap(c, c+1)
+        end
+      end
+      true
+    end
+
+    # Release a previously acquired read lock.
+    #
+    # @return [Boolean] true if the lock is successfully released
+    def release_read_lock
+      while true
+        c = @Counter.value
+        if @Counter.compare_and_swap(c, c-1)
+          # If one or more writers were waiting, and we were the last reader, wake a writer up
+          if waiting_writer?(c) && running_readers(c) == 1
+            @WriteLock.signal
+          end
+          break
+        end
+      end
+      true
+    end
+
+    # Acquire a write lock. Will block and wait for all active readers and writers.
+    #
+    # @return [Boolean] true if the lock is successfully acquired
+    #
+    # @raise [Concurrent::ResourceLimitError] if the maximum number of writers
+    #   is exceeded.
+    def acquire_write_lock
+      while true
+        c = @Counter.value
+        raise ResourceLimitError.new('Too many writer threads') if max_writers?(c)
+
+        if c == 0 # no readers OR writers running
+          # if we successfully swap the RUNNING_WRITER bit on, then we can go ahead
+          break if @Counter.compare_and_swap(0, RUNNING_WRITER)
+        elsif @Counter.compare_and_swap(c, c+WAITING_WRITER)
+          while true
+            # Now we have successfully incremented, so no more readers will be able to increment
+            #   (they will wait instead)
+            # However, readers OR writers could decrement right here, OR another writer could increment
+            @WriteLock.wait_until do
+              # So we have to do another check inside the synchronized section
+              # If a writer OR reader is running, then go to sleep
+              c = @Counter.value
+              !running_writer?(c) && !running_readers?(c)
+            end
+
+            # We just came out of a wait
+            # If we successfully turn the RUNNING_WRITER bit on with an atomic swap,
+            # Then we are OK to stop waiting and go ahead
+            # Otherwise go back and wait again
+            c = @Counter.value
+            break if !running_writer?(c) && !running_readers?(c) && @Counter.compare_and_swap(c, c+RUNNING_WRITER-WAITING_WRITER)
+          end
+          break
+        end
+      end
+      true
+    end
+
+    # Release a previously acquired write lock.
+    #
+    # @return [Boolean] true if the lock is successfully released
+    def release_write_lock
+      c = @Counter.update { |c| c-RUNNING_WRITER }
+      @ReadLock.broadcast
+      @WriteLock.signal if waiting_writers(c) > 0
+      true
+    end
+
+    # Queries if the write lock is held by any thread.
+    #
+    # @return [Boolean] true if the write lock is held else false`
+    def write_locked?
+      @Counter.value >= RUNNING_WRITER
+    end
+
+    # Queries whether any threads are waiting to acquire the read or write lock.
+    #
+    # @return [Boolean] true if any threads are waiting for a lock else false
+    def has_waiters?
+      waiting_writer?(@Counter.value)
+    end
+
+    private
+
+    # @!visibility private
+    def running_readers(c = @Counter.value)
+      c & MAX_READERS
+    end
+
+    # @!visibility private
+    def running_readers?(c = @Counter.value)
+      (c & MAX_READERS) > 0
+    end
+
+    # @!visibility private
+    def running_writer?(c = @Counter.value)
+      c >= RUNNING_WRITER
+    end
+
+    # @!visibility private
+    def waiting_writers(c = @Counter.value)
+      (c & MAX_WRITERS) / WAITING_WRITER
+    end
+
+    # @!visibility private
+    def waiting_writer?(c = @Counter.value)
+      c >= WAITING_WRITER
+    end
+
+    # @!visibility private
+    def max_readers?(c = @Counter.value)
+      (c & MAX_READERS) == MAX_READERS
+    end
+
+    # @!visibility private
+    def max_writers?(c = @Counter.value)
+      (c & MAX_WRITERS) == MAX_WRITERS
+    end
+  end
+end