o-concurrent-ruby 1.1.11

data/lib/concurrent-ruby/concurrent/atomic/semaphore.rb

@@ -0,0 +1,166 @@
+require 'concurrent/atomic/mutex_semaphore'
+require 'concurrent/synchronization'
+
+module Concurrent
+
+  ###################################################################
+
+  # @!macro semaphore_method_initialize
+  #
+  #   Create a new `Semaphore` with the initial `count`.
+  #
+  #   @param [Fixnum] count the initial count
+  #
+  #   @raise [ArgumentError] if `count` is not an integer or is less than zero
+
+  # @!macro semaphore_method_acquire
+  #
+  #   Acquires the given number of permits from this semaphore,
+  #     blocking until all are available. If a block is given,
+  #     yields to it and releases the permits afterwards.
+  #
+  #   @param [Fixnum] permits Number of permits to acquire
+  #
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than
+  #     one
+  #
+  #   @return [nil, BasicObject] Without a block, `nil` is returned. If a block
+  #   is given, its return value is returned.
+
+  # @!macro semaphore_method_available_permits
+  #
+  #   Returns the current number of permits available in this semaphore.
+  #
+  #   @return [Integer]
+
+  # @!macro semaphore_method_drain_permits
+  #
+  #   Acquires and returns all permits that are immediately available.
+  #
+  #   @return [Integer]
+
+  # @!macro semaphore_method_try_acquire
+  #
+  #   Acquires the given number of permits from this semaphore,
+  #     only if all are available at the time of invocation or within
+  #     `timeout` interval. If a block is given, yields to it if the permits
+  #     were successfully acquired, and releases them afterward, returning the
+  #     block's return value.
+  #
+  #   @param [Fixnum] permits the number of permits to acquire
+  #
+  #   @param [Fixnum] timeout the number of seconds to wait for the counter
+  #     or `nil` to return immediately
+  #
+  #   @raise [ArgumentError] if `permits` is not an integer or is less than
+  #     one
+  #
+  #   @return [true, false, nil, BasicObject] `false` if no permits are
+  #     available, `true` when acquired a permit. If a block is given, the
+  #     block's return value is returned if the permits were acquired; if not,
+  #     `nil` is returned.
+
+  # @!macro semaphore_method_release
+  #
+  #   Releases the given number of permits, returning them to the semaphore.
+  #
+  #   @param [Fixnum] permits Number of permits to return to the semaphore.
+  #
+  #   @raise [ArgumentError] if `permits` is not a number or is less than one
+  #
+  #   @return [nil]
+
+  ###################################################################
+
+  # @!macro semaphore_public_api
+  #
+  #   @!method initialize(count)
+  #     @!macro semaphore_method_initialize
+  #
+  #   @!method acquire(permits = 1)
+  #     @!macro semaphore_method_acquire
+  #
+  #   @!method available_permits
+  #     @!macro semaphore_method_available_permits
+  #
+  #   @!method drain_permits
+  #     @!macro semaphore_method_drain_permits
+  #
+  #   @!method try_acquire(permits = 1, timeout = nil)
+  #     @!macro semaphore_method_try_acquire
+  #
+  #   @!method release(permits = 1)
+  #     @!macro semaphore_method_release
+
+  ###################################################################
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  SemaphoreImplementation = case
+                            when defined?(JavaSemaphore)
+                              JavaSemaphore
+                            else
+                              MutexSemaphore
+                            end
+  private_constant :SemaphoreImplementation
+
+  # @!macro semaphore
+  #
+  #   A counting semaphore. Conceptually, a semaphore maintains a set of
+  #   permits. Each {#acquire} blocks if necessary until a permit is
+  #   available, and then takes it. Each {#release} adds a permit, potentially
+  #   releasing a blocking acquirer.
+  #   However, no actual permit objects are used; the Semaphore just keeps a
+  #   count of the number available and acts accordingly.
+  #   Alternatively, permits may be acquired within a block, and automatically
+  #   released after the block finishes executing.
+  #
+  # @!macro semaphore_public_api
+  # @example
+  #   semaphore = Concurrent::Semaphore.new(2)
+  #
+  #   t1 = Thread.new do
+  #     semaphore.acquire
+  #     puts "Thread 1 acquired semaphore"
+  #   end
+  #
+  #   t2 = Thread.new do
+  #     semaphore.acquire
+  #     puts "Thread 2 acquired semaphore"
+  #   end
+  #
+  #   t3 = Thread.new do
+  #     semaphore.acquire
+  #     puts "Thread 3 acquired semaphore"
+  #   end
+  #
+  #   t4 = Thread.new do
+  #     sleep(2)
+  #     puts "Thread 4 releasing semaphore"
+  #     semaphore.release
+  #   end
+  #
+  #   [t1, t2, t3, t4].each(&:join)
+  #
+  #   # prints:
+  #   # Thread 3 acquired semaphore
+  #   # Thread 2 acquired semaphore
+  #   # Thread 4 releasing semaphore
+  #   # Thread 1 acquired semaphore
+  #
+  # @example
+  #   semaphore = Concurrent::Semaphore.new(1)
+  #
+  #   puts semaphore.available_permits
+  #   semaphore.acquire do
+  #     puts semaphore.available_permits
+  #   end
+  #   puts semaphore.available_permits
+  #
+  #   # prints:
+  #   # 1
+  #   # 0
+  #   # 1
+  class Semaphore < SemaphoreImplementation
+  end
+end

data/lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb

@@ -0,0 +1,104 @@
+require 'concurrent/utility/engine'
+require 'concurrent/atomic/ruby_thread_local_var'
+require 'concurrent/atomic/java_thread_local_var'
+
+module Concurrent
+
+  ###################################################################
+
+  # @!macro thread_local_var_method_initialize
+  #
+  #   Creates a thread local variable.
+  #
+  #   @param [Object] default the default value when otherwise unset
+  #   @param [Proc] default_block Optional block that gets called to obtain the
+  #     default value for each thread
+
+  # @!macro thread_local_var_method_get
+  #
+  #   Returns the value in the current thread's copy of this thread-local variable.
+  #
+  #   @return [Object] the current value
+
+  # @!macro thread_local_var_method_set
+  #
+  #   Sets the current thread's copy of this thread-local variable to the specified value.
+  #
+  #   @param [Object] value the value to set
+  #   @return [Object] the new value
+
+  # @!macro thread_local_var_method_bind
+  #
+  #   Bind the given value to thread local storage during
+  #   execution of the given block.
+  #
+  #   @param [Object] value the value to bind
+  #   @yield the operation to be performed with the bound variable
+  #   @return [Object] the value
+
+
+  ###################################################################
+
+  # @!macro thread_local_var_public_api
+  #
+  #   @!method initialize(default = nil, &default_block)
+  #     @!macro thread_local_var_method_initialize
+  #
+  #   @!method value
+  #     @!macro thread_local_var_method_get
+  #
+  #   @!method value=(value)
+  #     @!macro thread_local_var_method_set
+  #
+  #   @!method bind(value, &block)
+  #     @!macro thread_local_var_method_bind
+
+  ###################################################################
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  ThreadLocalVarImplementation = case
+                                 when Concurrent.on_jruby?
+                                   JavaThreadLocalVar
+                                 else
+                                   RubyThreadLocalVar
+                                 end
+  private_constant :ThreadLocalVarImplementation
+
+  # @!macro thread_local_var
+  #
+  #   A `ThreadLocalVar` is a variable where the value is different for each thread.
+  #   Each variable may have a default value, but when you modify the variable only
+  #   the current thread will ever see that change.
+  #
+  #   @!macro thread_safe_variable_comparison
+  #
+  #   @example
+  #     v = ThreadLocalVar.new(14)
+  #     v.value #=> 14
+  #     v.value = 2
+  #     v.value #=> 2
+  #
+  #   @example
+  #     v = ThreadLocalVar.new(14)
+  #
+  #     t1 = Thread.new do
+  #       v.value #=> 14
+  #       v.value = 1
+  #       v.value #=> 1
+  #     end
+  #
+  #     t2 = Thread.new do
+  #       v.value #=> 14
+  #       v.value = 2
+  #       v.value #=> 2
+  #     end
+  #
+  #     v.value #=> 14
+  #
+  #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal
+  #
+  # @!macro thread_local_var_public_api
+  class ThreadLocalVar < ThreadLocalVarImplementation
+  end
+end

data/lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb

@@ -0,0 +1,56 @@
+module Concurrent
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  class MutexAtomicReference < Synchronization::LockableObject
+    include AtomicDirectUpdate
+    include AtomicNumericCompareAndSetWrapper
+    alias_method :compare_and_swap, :compare_and_set
+
+    # @!macro atomic_reference_method_initialize
+    def initialize(value = nil)
+      super()
+      synchronize { ns_initialize(value) }
+    end
+
+    # @!macro atomic_reference_method_get
+    def get
+      synchronize { @value }
+    end
+    alias_method :value, :get
+
+    # @!macro atomic_reference_method_set
+    def set(new_value)
+      synchronize { @value = new_value }
+    end
+    alias_method :value=, :set
+
+    # @!macro atomic_reference_method_get_and_set
+    def get_and_set(new_value)
+      synchronize do
+        old_value = @value
+        @value = new_value
+        old_value
+      end
+    end
+    alias_method :swap, :get_and_set
+
+    # @!macro atomic_reference_method_compare_and_set
+    def _compare_and_set(old_value, new_value)
+      synchronize do
+        if @value.equal? old_value
+          @value = new_value
+          true
+        else
+          false
+        end
+      end
+    end
+
+    protected
+
+    def ns_initialize(value)
+      @value = value
+    end
+  end
+end

data/lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb

@@ -0,0 +1,28 @@
+module Concurrent
+
+  # Special "compare and set" handling of numeric values.
+  #
+  # @!visibility private
+  # @!macro internal_implementation_note
+  module AtomicNumericCompareAndSetWrapper
+
+    # @!macro atomic_reference_method_compare_and_set
+    def compare_and_set(old_value, new_value)
+      if old_value.kind_of? Numeric
+        while true
+          old = get
+
+          return false unless old.kind_of? Numeric
+
+          return false unless old == old_value
+
+          result = _compare_and_set(old, new_value)
+          return result if result
+        end
+      else
+        _compare_and_set(old_value, new_value)
+      end
+    end
+
+  end
+end

data/lib/concurrent-ruby/concurrent/atomics.rb

@@ -0,0 +1,10 @@
+require 'concurrent/atomic/atomic_reference'
+require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/cyclic_barrier'
+require 'concurrent/atomic/count_down_latch'
+require 'concurrent/atomic/event'
+require 'concurrent/atomic/read_write_lock'
+require 'concurrent/atomic/reentrant_read_write_lock'
+require 'concurrent/atomic/semaphore'
+require 'concurrent/atomic/thread_local_var'

data/lib/concurrent-ruby/concurrent/collection/copy_on_notify_observer_set.rb

@@ -0,0 +1,107 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # 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
+    #
+    # @api private
+    class CopyOnNotifyObserverSet < Synchronization::LockableObject
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # @!macro observable_add_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
+
+        synchronize do
+          @observers[observer] = func
+          observer
+        end
+      end
+
+      # @!macro observable_delete_observer
+      def delete_observer(observer)
+        synchronize do
+          @observers.delete(observer)
+          observer
+        end
+      end
+
+      # @!macro observable_delete_observers
+      def delete_observers
+        synchronize do
+          @observers.clear
+          self
+        end
+      end
+
+      # @!macro observable_count_observers
+      def count_observers
+        synchronize { @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)
+        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
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      end
+
+      private
+
+      def duplicate_and_clear_observers
+        synchronize do
+          observers = @observers.dup
+          @observers.clear
+          observers
+        end
+      end
+
+      def duplicate_observers
+        synchronize { @observers.dup }
+      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
+end

data/lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb

@@ -0,0 +1,111 @@
+require 'concurrent/synchronization'
+
+module Concurrent
+  module Collection
+
+    # 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.
+    #
+    # @api private
+    class CopyOnWriteObserverSet < Synchronization::LockableObject
+
+      def initialize
+        super()
+        synchronize { ns_initialize }
+      end
+
+      # @!macro observable_add_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
+
+        synchronize do
+          new_observers = @observers.dup
+          new_observers[observer] = func
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # @!macro observable_delete_observer
+      def delete_observer(observer)
+        synchronize do
+          new_observers = @observers.dup
+          new_observers.delete(observer)
+          @observers = new_observers
+          observer
+        end
+      end
+
+      # @!macro observable_delete_observers
+      def delete_observers
+        self.observers = {}
+        self
+      end
+
+      # @!macro observable_count_observers
+      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
+
+      protected
+
+      def ns_initialize
+        @observers = {}
+      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
+        synchronize { @observers }
+      end
+
+      def observers=(new_set)
+        synchronize { @observers = new_set }
+      end
+
+      def clear_observers_and_return_old
+        synchronize do
+          old_observers = @observers
+          @observers = {}
+          old_observers
+        end
+      end
+    end
+  end
+end

data/lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb

@@ -0,0 +1,84 @@
+if Concurrent.on_jruby?
+
+  module Concurrent
+    module Collection
+
+
+      # @!macro priority_queue
+      # 
+      # @!visibility private
+      # @!macro internal_implementation_note
+      class JavaNonConcurrentPriorityQueue
+
+        # @!macro priority_queue_method_initialize
+        def initialize(opts = {})
+          order = opts.fetch(:order, :max)
+          if [:min, :low].include?(order)
+            @queue = java.util.PriorityQueue.new(11) # 11 is the default initial capacity
+          else
+            @queue = java.util.PriorityQueue.new(11, java.util.Collections.reverseOrder())
+          end
+        end
+
+        # @!macro priority_queue_method_clear
+        def clear
+          @queue.clear
+          true
+        end
+
+        # @!macro priority_queue_method_delete
+        def delete(item)
+          found = false
+          while @queue.remove(item) do
+            found = true
+          end
+          found
+        end
+
+        # @!macro priority_queue_method_empty
+        def empty?
+          @queue.size == 0
+        end
+
+        # @!macro priority_queue_method_include
+        def include?(item)
+          @queue.contains(item)
+        end
+        alias_method :has_priority?, :include?
+
+        # @!macro priority_queue_method_length
+        def length
+          @queue.size
+        end
+        alias_method :size, :length
+
+        # @!macro priority_queue_method_peek
+        def peek
+          @queue.peek
+        end
+
+        # @!macro priority_queue_method_pop
+        def pop
+          @queue.poll
+        end
+        alias_method :deq, :pop
+        alias_method :shift, :pop
+
+        # @!macro priority_queue_method_push
+        def push(item)
+          raise ArgumentError.new('cannot enqueue nil') if item.nil?
+          @queue.add(item)
+        end
+        alias_method :<<, :push
+        alias_method :enq, :push
+
+        # @!macro priority_queue_method_from_list
+        def self.from_list(list, opts = {})
+          queue = new(opts)
+          list.each{|item| queue << item }
+          queue
+        end
+      end
+    end
+  end
+end