concurrent-ruby 0.6.0.pre.1 → 0.6.0.pre.2

data/lib/concurrent/{copy_on_notify_observer_set.rb → atomic/copy_on_notify_observer_set.rb}

@@ -12,37 +12,63 @@ module Concurrent
     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 [Symbol] the added function
-    def add_observer(observer, func=:update)
-      @mutex.synchronize { @observers[observer] = func }
+    # @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
+
+      @mutex.lock
+      @observers[observer] = func
+      @mutex.unlock
+
+      observer
     end
 
     # @param [Object] observer the observer to remove
     # @return [Object] the deleted observer
     def delete_observer(observer)
-      @mutex.synchronize { @observers.delete(observer) }
+      @mutex.lock
+      @observers.delete(observer)
+      @mutex.unlock
+
       observer
     end
 
     # Deletes all observers
     # @return [CopyOnWriteObserverSet] self
     def delete_observers
-      @mutex.synchronize { @observers.clear }
+      @mutex.lock
+      @observers.clear
+      @mutex.unlock
+
       self
     end
 
     # @return [Integer] the observers count
     def count_observers
-      @mutex.synchronize { @observers.count }
+      @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 = @mutex.synchronize { @observers.dup }
+      observers = duplicate_observers
       notify_to(observers, *args, &block)
 
       self
@@ -62,15 +88,24 @@ module Concurrent
     private
 
     def duplicate_and_clear_observers
-      @mutex.synchronize do
-        observers = @observers.dup
-        @observers.clear
-        observers
-      end
+      @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?
+      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)

data/lib/concurrent/{copy_on_write_observer_set.rb → atomic/copy_on_write_observer_set.rb}

@@ -11,26 +11,40 @@ module Concurrent
     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 [Symbol] the added function
-    def add_observer(observer, func=:update)
-      @mutex.synchronize do
-        new_observers = @observers.dup
-        new_observers[observer] = func
-        @observers = new_observers
+    # @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
-      func
+
+      if block
+        observer = block
+        func = :call
+      end
+
+      @mutex.lock
+      new_observers = @observers.dup
+      new_observers[observer] = func
+      @observers = new_observers
+      @mutex.unlock
+
+      observer
     end
 
     # @param [Object] observer the observer to remove
     # @return [Object] the deleted observer
     def delete_observer(observer)
-      @mutex.synchronize do
-        new_observers = @observers.dup
-        new_observers.delete(observer)
-        @observers = new_observers
-      end
+      @mutex.lock
+      new_observers = @observers.dup
+      new_observers.delete(observer)
+      @observers = new_observers
+      @mutex.unlock
+
       observer
     end
 
@@ -68,7 +82,7 @@ module Concurrent
     private
 
     def notify_to(observers, *args)
-      raise ArgumentError.new('cannot give arguments and a block') if block_given? && ! args.empty?
+      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)
@@ -76,19 +90,26 @@ module Concurrent
     end
 
     def observers
-      @mutex.synchronize { @observers }
+      @mutex.lock
+      o = @observers
+      @mutex.unlock
+
+      o
     end
 
     def observers=(new_set)
-      @mutex.synchronize { @observers = new_set}
+      @mutex.lock
+      @observers = new_set
+      @mutex.unlock
     end
 
     def clear_observers_and_return_old
-      @mutex.synchronize do
-        old_observers = @observers
-        @observers = {}
-        old_observers
-      end
+      @mutex.lock
+      old_observers = @observers
+      @observers = {}
+      @mutex.unlock
+
+      old_observers
     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

data/lib/concurrent/atomic/event.rb

@@ -0,0 +1,103 @@
+require 'thread'
+require 'concurrent/utilities'
+require 'concurrent/atomic/condition'
+
+module Concurrent
+
+  # Old school kernel-style event reminiscent of Win32 programming in C++.
+  #
+  # When an `Event` is created it is in the `unset` state. Threads can choose to
+  # `#wait` on the event, blocking until released by another thread. When one
+  # thread wants to alert all blocking threads it calls the `#set` method which
+  # will then wake up all listeners. Once an `Event` has been set it remains set.
+  # New threads calling `#wait` will return immediately. An `Event` may be
+  # `#reset` at any time once it has been set.
+  #
+  # @see http://msdn.microsoft.com/en-us/library/windows/desktop/ms682655.aspx
+  class Event
+
+    # 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
+    end
+
+    # Is the object in the set state?
+    #
+    # @return [Boolean] indicating whether or not the `Event` has been set
+    def set?
+      @mutex.lock
+      result = @set
+      @mutex.unlock
+
+      result
+    end
+
+    # Trigger the event, setting the state to `set` and releasing all threads
+    # waiting on the event. Has no effect if the `Event` has already been set.
+    #
+    # @return [Boolean] should always return `true`
+    def set
+      @mutex.lock
+      unless @set
+        @set = true
+        @condition.broadcast
+      end
+      @mutex.unlock
+
+      true
+    end
+
+    def try?
+      @mutex.lock
+
+      if @set
+        result = false
+      else
+        @set = true
+        @condition.broadcast
+        result = true
+      end
+
+      @mutex.unlock
+
+      result
+    end
+
+    # Reset a previously set event back to the `unset` state.
+    # Has no effect if the `Event` has not yet been set.
+    #
+    # @return [Boolean] should always return `true`
+    def reset
+      @mutex.lock
+      @set = false
+      @mutex.unlock
+
+      true
+    end
+
+    # Wait a given number of seconds for the `Event` to be set by another
+    # thread. Will wait forever when no `timeout` value is given. Returns
+    # immediately if the `Event` has already been set.
+    #
+    # @return [Boolean] true if the `Event` was set before timeout else false
+    def wait(timeout = nil)
+      @mutex.lock
+
+      unless @set
+        remaining = Condition::Result.new(timeout)
+        while !@set && remaining.can_wait?
+          remaining = @condition.wait(@mutex, remaining.remaining_time)
+        end
+      end
+
+      result = @set
+
+      @mutex.unlock
+
+      result
+    end
+  end
+end