concurrent-ruby 0.7.0.rc0-x86-mingw32

data/lib/concurrent/atomic.rb

@@ -0,0 +1,46 @@
+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 = defined?(RUBY_ENGINE)? RUBY_ENGINE : 'ruby'
+  end
+
+  require "concurrent/atomic_reference/#{ruby_engine}"
+rescue LoadError
+  warn 'Compiled extensions not installed, pure Ruby Atomic will be used.'
+end
+
+if defined? Concurrent::JavaAtomic
+
+  class Concurrent::Atomic < Concurrent::JavaAtomic
+  end
+
+elsif defined? Concurrent::CAtomic
+
+  class Concurrent::Atomic < Concurrent::CAtomic
+  end
+
+elsif defined? Concurrent::RbxAtomic
+
+  class Concurrent::Atomic < Concurrent::RbxAtomic
+  end
+
+else
+
+  class Concurrent::Atomic < Concurrent::MutexAtomic
+  end
+end
+
+class Atomic < Concurrent::Atomic
+
+  ConcurrentUpdateError = Class.new(Concurrent::ConcurrentUpdateError)
+
+  def initialize(*args)
+    warn "[DEPRECATED] Please use Concurrent::Atomic instead."
+    super
+  end
+end

data/lib/concurrent/atomic/atomic_boolean.rb

@@ -0,0 +1,157 @@
+module Concurrent
+
+  # @!macro [attach] atomic_boolean
+  #
+  #   A boolean value that can be updated atomically. Reads and writes to an atomic
+  #   boolean and thread-safe and guaranteed to succeed. Reads and writes may block
+  #   briefly but no explicit locking is required.
+  #
+  #   @since 0.6.0
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicBoolean.html java.util.concurrent.atomic.AtomicBoolean
+  class MutexAtomicBoolean
+
+    # @!macro [attach] atomic_boolean_method_initialize
+    #
+    # Creates a new `AtomicBoolean` with the given initial value.
+    #
+    # @param [Boolean] initial the initial value
+    def initialize(initial = false)
+      @value = !!initial
+      @mutex = Mutex.new
+    end
+
+    # @!macro [attach] atomic_boolean_method_value
+    #
+    #   Retrieves the current `Boolean` value.
+    #
+    #   @return [Boolean] the current value
+    def value
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_value_eq
+    #
+    #   Explicitly sets the value.
+    #
+    #   @param [Boolean] value the new value to be set
+    #
+    #   @return [Boolean] the current value
+    def value=(value)
+      @mutex.lock
+      @value = !!value
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_is_true
+    #
+    #   Is the current value `true`?
+    #
+    #   @return [Boolean] true if the current value is `true`, else false
+    def true?
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_is_false
+    #
+    #   Is the current value `true`?false
+    #
+    #   @return [Boolean] true if the current value is `false`, else false
+    def false?
+      @mutex.lock
+      !@value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_make_true
+    #
+    #   Explicitly sets the value to true.
+    #
+    #   @return [Boolean] true is value has changed, otherwise false
+    def make_true
+      @mutex.lock
+      old = @value
+      @value = true
+      !old
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_boolean_method_make_false
+    #
+    #   Explicitly sets the value to false.
+    #
+    #   @return [Boolean] true is value has changed, otherwise false
+    def make_false
+      @mutex.lock
+      old = @value
+      @value = false
+      old
+    ensure
+      @mutex.unlock
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro atomic_boolean
+    class JavaAtomicBoolean
+
+      # @!macro atomic_boolean_method_initialize
+      #
+      def initialize(initial = false)
+        @atomic = java.util.concurrent.atomic.AtomicBoolean.new(!!initial)
+      end
+
+      # @!macro atomic_boolean_method_value
+      #
+      def value
+        @atomic.get
+      end
+
+      # @!macro atomic_boolean_method_value_eq
+      #
+      def value=(value)
+        @atomic.set(!!value)
+      end
+
+      # @!macro [attach] atomic_boolean_method_is_true
+      def true?
+        @atomic.get
+      end
+
+      # @!macro [attach] atomic_boolean_method_is_false
+      def false?
+        !@atomic.get
+      end
+
+      # @!macro atomic_boolean_method_make_true
+      def make_true
+        @atomic.compareAndSet(false, true)
+      end
+
+      # @!macro atomic_boolean_method_make_false
+      def make_false
+        @atomic.compareAndSet(true, false)
+      end
+    end
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < JavaAtomicBoolean
+    end
+
+  else
+
+    # @!macro atomic_boolean
+    class AtomicBoolean < MutexAtomicBoolean
+    end
+  end
+end

data/lib/concurrent/atomic/atomic_fixnum.rb

@@ -0,0 +1,162 @@
+module Concurrent
+
+  # @!macro [attach] atomic_fixnum
+  #
+  #   A numeric value that can be updated atomically. Reads and writes to an atomic
+  #   fixnum and thread-safe and guaranteed to succeed. Reads and writes may block
+  #   briefly but no explicit locking is required.
+  #
+  #   @since 0.5.0
+  #   @see http://docs.oracle.com/javase/7/docs/api/java/util/concurrent/atomic/AtomicLong.html java.util.concurrent.atomic.AtomicLong
+  class MutexAtomicFixnum
+
+    # @!macro [attach] atomic_fixnum_method_initialize
+    #
+    # Creates a new `AtomicFixnum` with the given initial value.
+    #
+    # @param [Fixnum] init 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
+    end
+
+    # @!macro [attach] atomic_fixnum_method_value
+    #
+    #   Retrieves the current `Fixnum` value.
+    #
+    #   @return [Fixnum] the current value
+    def value
+      @mutex.lock
+      @value
+    ensure
+      @mutex.unlock
+    end
+
+    # @!macro [attach] atomic_fixnum_method_value_eq
+    #
+    #   Explicitly sets the value.
+    #
+    #   @param [Fixnum] value the new value to be set
+    #
+    #   @return [Fixnum] the current value
+    #
+    #   @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
+    end
+
+    # @!macro [attach] atomic_fixnum_method_increment
+    #
+    #   Increases the current value by 1.
+    #
+    #   @return [Fixnum] the current value after incrementation
+    def increment
+      @mutex.lock
+      @value += 1
+    ensure
+      @mutex.unlock
+    end
+
+    alias_method :up, :increment
+
+    # @!macro [attach] atomic_fixnum_method_decrement
+    #
+    #   Decreases the current value by 1.
+    #
+    #   @return [Fixnum] the current value after decrementation
+    def decrement
+      @mutex.lock
+      @value -= 1
+    ensure
+      @mutex.unlock
+    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 
+    def compare_and_set(expect, update)
+      @mutex.lock
+      if @value == expect
+        @value = update
+        true
+      else
+        false
+      end
+    ensure
+      @mutex.unlock
+    end
+  end
+
+  if RUBY_PLATFORM == 'java'
+
+    # @!macro atomic_fixnum
+    class JavaAtomicFixnum
+
+      # @!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
+      #
+      def value
+        @atomic.get
+      end
+
+      # @!macro atomic_fixnum_method_value_eq
+      #
+      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
+
+      # @!macro atomic_fixnum_method_decrement
+      #
+      def decrement
+        @atomic.decrement_and_get
+      end
+
+      alias_method :down, :decrement
+
+      # @!macro atomic_fixnum_method_compare_and_set
+      #
+      def compare_and_set(expect, update)
+        @atomic.compare_and_set(expect, update)
+      end
+    end
+
+    # @!macro atomic_fixnum
+    class AtomicFixnum < JavaAtomicFixnum
+    end
+
+  else
+
+    # @!macro atomic_fixnum
+    class AtomicFixnum < MutexAtomicFixnum
+    end
+  end
+end

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