concurrent-ruby 0.7.0-java

data/lib/concurrent/atomic/condition.rb

@@ -0,0 +1,67 @@
+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.
+  #
+  # 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
+  class Condition
+
+    class Result
+      def initialize(remaining_time)
+        @remaining_time = remaining_time
+      end
+
+      attr_reader :remaining_time
+
+      # @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
+      def timed_out?
+        @remaining_time != nil && @remaining_time <= 0
+      end
+
+      alias_method :can_wait?, :woken_up?
+
+    end
+
+    def initialize
+      @condition = ConditionVariable.new
+    end
+
+    # @param [Mutex] mutex the locked mutex guarding the wait
+    # @param [Object] timeout nil means no timeout
+    # @return [Result]
+    def wait(mutex, timeout = nil)
+      start_time = Time.now.to_f
+      @condition.wait(mutex, timeout)
+
+      if timeout.nil?
+        Result.new(nil)
+      else
+        Result.new(start_time + timeout - Time.now.to_f)
+      end
+    end
+
+    # Wakes up a waiting thread
+    # @return [true]
+    def signal
+      @condition.signal
+      true
+    end
+
+    # Wakes up all waiting threads
+    # @return [true]
+    def broadcast
+      @condition.broadcast
+      true
+    end
+
+  end
+end

data/lib/concurrent/atomic/copy_on_notify_observer_set.rb

@@ -0,0 +1,118 @@
+module Concurrent
+
+  # A thread safe observer set implemented using copy-on-read approach:
+  # observers are added and removed from a thread safe collection; every time
+  # a notification is required the internal data structure is copied to
+  # prevent concurrency issues
+  class CopyOnNotifyObserverSet
+
+    def initialize
+      @mutex = Mutex.new
+      @observers = {}
+    end
+
+    # Adds an observer to this set
+    # If a block is passed, the observer will be created by this method and no other params should be passed
+    # @param [Object] observer the observer to add
+    # @param [Symbol] func the function to call on the observer during notification. Default is :update
+    # @return [Object] the added observer
+    def add_observer(observer=nil, func=:update, &block)
+      if observer.nil? && block.nil?
+        raise ArgumentError, 'should pass observer as a first argument or block'
+      elsif observer && block
+        raise ArgumentError.new('cannot provide both an observer and a block')
+      end
+
+      if block
+        observer = block
+        func = :call
+      end
+
+      begin
+        @mutex.lock
+        @observers[observer] = func
+      ensure
+        @mutex.unlock
+      end
+
+        observer
+    end
+
+    # @param [Object] observer the observer to remove
+    # @return [Object] the deleted observer
+    def delete_observer(observer)
+      @mutex.lock
+      @observers.delete(observer)
+      @mutex.unlock
+
+      observer
+    end
+
+    # Deletes all observers
+    # @return [CopyOnWriteObserverSet] self
+    def delete_observers
+      @mutex.lock
+      @observers.clear
+      @mutex.unlock
+
+      self
+    end
+
+    # @return [Integer] the observers count
+    def count_observers
+      @mutex.lock
+      result = @observers.count
+      @mutex.unlock
+
+      result
+    end
+
+    # Notifies all registered observers with optional args
+    # @param [Object] args arguments to be passed to each observer
+    # @return [CopyOnWriteObserverSet] self
+    def notify_observers(*args, &block)
+      observers = duplicate_observers
+      notify_to(observers, *args, &block)
+
+      self
+    end
+
+    # Notifies all registered observers with optional args and deletes them.
+    #
+    # @param [Object] args arguments to be passed to each observer
+    # @return [CopyOnWriteObserverSet] self
+    def notify_and_delete_observers(*args, &block)
+      observers = duplicate_and_clear_observers
+      notify_to(observers, *args, &block)
+
+      self
+    end
+
+    private
+
+    def duplicate_and_clear_observers
+      @mutex.lock
+      observers = @observers.dup
+      @observers.clear
+      @mutex.unlock
+
+      observers
+    end
+
+    def duplicate_observers
+      @mutex.lock
+      observers = @observers.dup
+      @mutex.unlock
+
+      observers
+    end
+
+    def notify_to(observers, *args)
+      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+      observers.each do |observer, function|
+        args = yield if block_given?
+        observer.send(function, *args)
+      end
+    end
+  end
+end

data/lib/concurrent/atomic/copy_on_write_observer_set.rb

@@ -0,0 +1,117 @@
+module Concurrent
+
+  # A thread safe observer set implemented using copy-on-write approach:
+  # every time an observer is added or removed the whole internal data structure is
+  # duplicated and replaced with a new one.
+  class CopyOnWriteObserverSet
+
+    def initialize
+      @mutex = Mutex.new
+      @observers = {}
+    end
+
+    # Adds an observer to this set
+    # If a block is passed, the observer will be created by this method and no other params should be passed
+    # @param [Object] observer the observer to add
+    # @param [Symbol] func the function to call on the observer during notification. Default is :update
+    # @return [Object] the added observer
+    def add_observer(observer=nil, func=:update, &block)
+      if observer.nil? && block.nil?
+        raise ArgumentError, 'should pass observer as a first argument or block'
+      elsif observer && block
+        raise ArgumentError.new('cannot provide both an observer and a block')
+      end
+
+      if block
+        observer = block
+        func = :call
+      end
+
+      begin
+        @mutex.lock
+        new_observers = @observers.dup
+        new_observers[observer] = func
+        @observers = new_observers
+        observer
+      ensure
+        @mutex.unlock
+      end
+    end
+
+    # @param [Object] observer the observer to remove
+    # @return [Object] the deleted observer
+    def delete_observer(observer)
+      @mutex.lock
+      new_observers = @observers.dup
+      new_observers.delete(observer)
+      @observers = new_observers
+      observer
+    ensure
+      @mutex.unlock
+    end
+
+    # Deletes all observers
+    # @return [CopyOnWriteObserverSet] self
+    def delete_observers
+      self.observers = {}
+      self
+    end
+
+
+    # @return [Integer] the observers count
+    def count_observers
+      observers.count
+    end
+
+    # Notifies all registered observers with optional args
+    # @param [Object] args arguments to be passed to each observer
+    # @return [CopyOnWriteObserverSet] self
+    def notify_observers(*args, &block)
+      notify_to(observers, *args, &block)
+      self
+    end
+
+    # Notifies all registered observers with optional args and deletes them.
+    #
+    # @param [Object] args arguments to be passed to each observer
+    # @return [CopyOnWriteObserverSet] self
+    def notify_and_delete_observers(*args, &block)
+      old = clear_observers_and_return_old
+      notify_to(old, *args, &block)
+      self
+    end
+
+    private
+
+    def notify_to(observers, *args)
+      raise ArgumentError.new('cannot give arguments and a block') if block_given? && !args.empty?
+      observers.each do |observer, function|
+        args = yield if block_given?
+        observer.send(function, *args)
+      end
+    end
+
+    def observers
+      @mutex.lock
+      @observers
+    ensure
+      @mutex.unlock
+    end
+
+    def observers=(new_set)
+      @mutex.lock
+      @observers = new_set
+    ensure
+      @mutex.unlock
+    end
+
+    def clear_observers_and_return_old
+      @mutex.lock
+      old_observers = @observers
+      @observers = {}
+      old_observers
+    ensure
+      @mutex.unlock
+    end
+  end
+end

data/lib/concurrent/atomic/count_down_latch.rb

@@ -0,0 +1,116 @@
+require 'concurrent/atomic/condition'
+
+module Concurrent
+
+  # @!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.
+  class MutexCountDownLatch
+
+    # @!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)
+      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
+    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)
+      @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
+    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
+      @mutex.synchronize do
+        @count -= 1 if @count > 0
+        @condition.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
+      @mutex.synchronize { @count }
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro count_down_latch
+    class JavaCountDownLatch
+
+      # @!macro count_down_latch_method_initialize
+      def initialize(count)
+        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 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 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 count_down_latch
+    class CountDownLatch < JavaCountDownLatch
+    end
+
+  else
+
+    # @!macro count_down_latch
+    class CountDownLatch < MutexCountDownLatch
+    end
+  end
+end

data/lib/concurrent/atomic/cyclic_barrier.rb

@@ -0,0 +1,106 @@
+module Concurrent
+
+  class CyclicBarrier
+
+    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
+    #
+    # @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)
+    end
+
+    # @return [Fixnum] the number of threads needed to pass the barrier
+    def parties
+      @parties
+    end
+
+    # @return [Fixnum] the number of threads currently waiting on the barrier
+    def number_waiting
+      @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
+    def wait(timeout = nil)
+      @mutex.synchronize do
+
+        return false unless @generation.status == :waiting
+
+        @number_waiting += 1
+
+        if @number_waiting == @parties
+          @action.call if @action
+          set_status_and_restore(:fulfilled)
+          true
+        else
+          wait_for_wake_up(@generation, timeout)
+        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 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
+    end
+
+    # A barrier can be broken when:
+    # - a thread called the `reset` method while at least one other thread was waiting
+    # - at least one thread timed out on `wait` method
+    #
+    # 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 }
+    end
+
+    private
+
+    def set_status_and_restore(new_status)
+      @generation.status = new_status
+      @condition.broadcast
+      @generation = Generation.new(:waiting)
+      @number_waiting = 0
+    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
+    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?
+    end
+
+  end
+end