concurrent-ruby 1.1.5 → 1.1.10

data/lib/{concurrent → concurrent-ruby/concurrent}/async.rb

@@ -58,26 +58,6 @@ module Concurrent
   # end
   # ```
   #
-  # When defining a constructor it is critical that the first line be a call to
-  # `super` with no arguments. The `super` method initializes the background
-  # thread and other asynchronous components.
-  #
-  # ```
-  # class BackgroundLogger
-  #   include Concurrent::Async
-  #
-  #   def initialize(level)
-  #     super()
-  #     @logger = Logger.new(STDOUT)
-  #     @logger.level = level
-  #   end
-  #
-  #   def info(msg)
-  #     @logger.info(msg)
-  #   end
-  # end
-  # ```
-  #
   # Mixing this module into a class provides each object two proxy methods:
   # `async` and `await`. These methods are thread safe with respect to the
   # enclosing object. The former proxy allows methods to be called
@@ -292,6 +272,7 @@ module Concurrent
         obj.send(:init_synchronization)
         obj
       end
+      ruby2_keywords :new if respond_to?(:ruby2_keywords, true)
     end
     private_constant :ClassMethods
 
@@ -309,6 +290,7 @@ module Concurrent
         @delegate = delegate
         @queue = []
         @executor = Concurrent.global_io_executor
+        @ruby_pid = $$
       end
 
       # Delegates method calls to the wrapped object.
@@ -326,6 +308,7 @@ module Concurrent
 
         ivar = Concurrent::IVar.new
         synchronize do
+          reset_if_forked
           @queue.push [ivar, method, args, block]
           @executor.post { perform } if @queue.length == 1
         end
@@ -361,6 +344,13 @@ module Concurrent
           end
         end
       end
+
+      def reset_if_forked
+        if $$ != @ruby_pid
+          @queue.clear
+          @ruby_pid = $$
+        end
+      end
     end
     private_constant :AsyncDelegator
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atom.rb

@@ -18,7 +18,7 @@ require 'concurrent/synchronization'
 #     uncoordinated, *synchronous* change of individual values. Best used when
 #     the value will undergo frequent reads but only occasional, though complex,
 #     updates. Suitable when the result of an update must be known immediately.
-#   * *{Concurrent::AtomicReference}:* A simple object reference that can be
+#   * *{Concurrent::AtomicReference}:* A simple object reference that can be updated
 #     atomically. Updates are synchronous but fast. Best used when updates a
 #     simple set operations. Not suitable when updates are complex.
 #     {Concurrent::AtomicBoolean} and {Concurrent::AtomicFixnum} are similar

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/atomic_boolean.rb

@@ -41,13 +41,13 @@ module Concurrent
   #
   #   Explicitly sets the value to true.
   #
-  #   @return [Boolean] true is value has changed, otherwise false
+  #   @return [Boolean] true if value has changed, otherwise false
 
   # @!macro atomic_boolean_method_make_false
   #
   #   Explicitly sets the value to false.
   #
-  #   @return [Boolean] true is value has changed, otherwise false
+  #   @return [Boolean] true if value has changed, otherwise false
 
   ###################################################################
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/atomic_reference.rb

@@ -170,6 +170,7 @@ module Concurrent
                                       alias_method :compare_and_swap, :compare_and_set
                                       alias_method :swap, :get_and_set
                                     end
+                                    TruffleRubyAtomicReference
                                   when Concurrent.on_rbx?
                                     # @note Extends `Rubinius::AtomicReference` version adding aliases
                                     #   and numeric logic.

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/count_down_latch.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/mutex_count_down_latch'
 require 'concurrent/atomic/java_count_down_latch'
-require 'concurrent/utility/engine'
 
 module Concurrent
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/event.rb

@@ -19,7 +19,7 @@ module Concurrent
   #   t1 = Thread.new do
   #     puts "t1 is waiting"
   #     event.wait(1)
-  #     puts "event ocurred"
+  #     puts "event occurred"
   #   end
   #
   #   t2 = Thread.new do
@@ -30,8 +30,8 @@ module Concurrent
   #   [t1, t2].each(&:join)
   #
   #   # prints:
-  #   # t2 calling set
   #   # t1 is waiting
+  #   # t2 calling set
   #   # event occurred
   class Event < Synchronization::LockableObject
 

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/mutex_semaphore.rb

@@ -23,7 +23,14 @@ module Concurrent
 
       synchronize do
         try_acquire_timed(permits, nil)
-        nil
+      end
+
+      return unless block_given?
+
+      begin
+        yield
+      ensure
+        release(permits)
       end
     end
 
@@ -48,13 +55,22 @@ module Concurrent
       Utility::NativeInteger.ensure_integer_and_bounds permits
       Utility::NativeInteger.ensure_positive permits
 
-      synchronize do
+      acquired = synchronize do
         if timeout.nil?
           try_acquire_now(permits)
         else
           try_acquire_timed(permits, timeout)
         end
       end
+
+      return acquired unless block_given?
+      return unless acquired
+
+      begin
+        yield
+      ensure
+        release(permits)
+      end
     end
 
     # @!macro semaphore_method_release

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/reentrant_read_write_lock.rb

@@ -267,12 +267,10 @@ module Concurrent
         #   running right now, AND no writers who came before us still waiting to
         #   acquire the lock
         # Additionally, if any read locks have been taken, we must hold all of them
-        if c == held
-          # If we successfully swap the RUNNING_WRITER bit on, then we can go ahead
-          if @Counter.compare_and_set(c, c+RUNNING_WRITER)
-            @HeldCount.value = held + WRITE_LOCK_HELD
-            return true
-          end
+        if held > 0 && @Counter.compare_and_set(1, c+RUNNING_WRITER)
+          # If we are the only one reader and successfully swap the RUNNING_WRITER bit on, then we can go ahead
+          @HeldCount.value = held + WRITE_LOCK_HELD
+          return true
         elsif @Counter.compare_and_set(c, c+WAITING_WRITER)
           while true
             # Now we have successfully incremented, so no more readers will be able to increment

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/ruby_thread_local_var.rb

@@ -28,16 +28,31 @@ module Concurrent
     # But when a Thread is GC'd, we need to drop the reference to its thread-local
     #   array, so we don't leak memory
 
-    # @!visibility private
-    FREE   = []
-    LOCK   = Mutex.new
-    ARRAYS = {} # used as a hash set
-    @@next = 0
-    private_constant :FREE, :LOCK, :ARRAYS
+    FREE                = []
+    LOCK                = Mutex.new
+    THREAD_LOCAL_ARRAYS = {} # used as a hash set
+
+    # synchronize when not on MRI
+    # on MRI using lock in finalizer leads to "can't be called from trap context" error
+    # so the code is carefully written to be tread-safe on MRI relying on GIL
+
+    if Concurrent.on_cruby?
+      # @!visibility private
+      def self.semi_sync(&block)
+        block.call
+      end
+    else
+      # @!visibility private
+      def self.semi_sync(&block)
+        LOCK.synchronize(&block)
+      end
+    end
+
+    private_constant :FREE, :LOCK, :THREAD_LOCAL_ARRAYS
 
     # @!macro thread_local_var_method_get
     def value
-      if array = get_threadlocal_array
+      if (array = get_threadlocal_array)
         value = array[@index]
         if value.nil?
           default
@@ -57,10 +72,10 @@ module Concurrent
       # We could keep the thread-local arrays in a hash, keyed by Thread
       # But why? That would require locking
       # Using Ruby's built-in thread-local storage is faster
-      unless array = get_threadlocal_array(me)
+      unless (array = get_threadlocal_array(me))
         array = set_threadlocal_array([], me)
-        LOCK.synchronize { ARRAYS[array.object_id] = array }
-        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
+        self.class.semi_sync { THREAD_LOCAL_ARRAYS[array.object_id] = array }
+        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array.object_id))
       end
       array[@index] = (value.nil? ? NULL : value)
       value
@@ -70,48 +85,52 @@ module Concurrent
 
     # @!visibility private
     def allocate_storage
-      @index = LOCK.synchronize do
-        FREE.pop || begin
-          result = @@next
-          @@next += 1
-          result
-        end
-      end
-      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
+      @index = FREE.pop || next_index
+
+      ObjectSpace.define_finalizer(self, self.class.thread_local_finalizer(@index))
     end
 
     # @!visibility private
-    def self.threadlocal_finalizer(index)
+    def self.thread_local_finalizer(index)
       proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            FREE.push(index)
-            # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-            # But that is natural! More threads means more storage is used per TLV
-            # So naturally more CPU time is required to free more storage
-            ARRAYS.each_value do |array|
-              array[index] = nil
-            end
-          end
+        semi_sync do
+          # The cost of GC'ing a TLV is linear in the number of threads using TLVs
+          # But that is natural! More threads means more storage is used per TLV
+          # So naturally more CPU time is required to free more storage
+          #
+          # DO NOT use each_value which might conflict with new pair assignment
+          # into the hash in #value= method
+          THREAD_LOCAL_ARRAYS.values.each { |array| array[index] = nil }
+          # free index has to be published after the arrays are cleared
+          FREE.push(index)
         end
       end
     end
 
     # @!visibility private
-    def self.thread_finalizer(array)
+    def self.thread_finalizer(id)
       proc do
-        Thread.new do # avoid error: can't be called from trap context
-          LOCK.synchronize do
-            # The thread which used this thread-local array is now gone
-            # So don't hold onto a reference to the array (thus blocking GC)
-            ARRAYS.delete(array.object_id)
-          end
+        semi_sync do
+          # The thread which used this thread-local array is now gone
+          # So don't hold onto a reference to the array (thus blocking GC)
+          THREAD_LOCAL_ARRAYS.delete(id)
         end
       end
     end
 
     private
 
+    # noinspection RubyClassVariableUsageInspection
+    @@next = 0
+    # noinspection RubyClassVariableUsageInspection
+    def next_index
+      LOCK.synchronize do
+        result = @@next
+        @@next += 1
+        result
+      end
+    end
+
     if Thread.instance_methods.include?(:thread_variable_get)
 
       def get_threadlocal_array(thread = Thread.current)
@@ -136,21 +155,22 @@ module Concurrent
     # This exists only for use in testing
     # @!visibility private
     def value_for(thread)
-      if array = get_threadlocal_array(thread)
+      if (array = get_threadlocal_array(thread))
         value = array[@index]
         if value.nil?
-          default_for(thread)
+          get_default
         elsif value.equal?(NULL)
           nil
         else
           value
         end
       else
-        default_for(thread)
+        get_default
       end
     end
 
-    def default_for(thread)
+    # @!visibility private
+    def get_default
       if @default_block
         raise "Cannot use default_for with default block"
       else

data/lib/{concurrent → concurrent-ruby/concurrent}/atomic/semaphore.rb

@@ -16,14 +16,16 @@ module Concurrent
   # @!macro semaphore_method_acquire
   #
   #   Acquires the given number of permits from this semaphore,
-  #     blocking until all are available.
+  #     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]
+  #   @return [nil, BasicObject] Without a block, `nil` is returned. If a block
+  #   is given, its return value is returned.
 
   # @!macro semaphore_method_available_permits
   #
@@ -41,7 +43,9 @@ module Concurrent
   #
   #   Acquires the given number of permits from this semaphore,
   #     only if all are available at the time of invocation or within
-  #     `timeout` interval
+  #     `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
   #
@@ -51,8 +55,10 @@ module Concurrent
   #   @raise [ArgumentError] if `permits` is not an integer or is less than
   #     one
   #
-  #   @return [Boolean] `false` if no permits are available, `true` when
-  #     acquired a permit
+  #   @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
   #
@@ -106,6 +112,8 @@ module Concurrent
   #   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
@@ -140,6 +148,19 @@ module Concurrent
   #   # 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 → concurrent-ruby/concurrent}/atomic/thread_local_var.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/atomic/ruby_thread_local_var'
 require 'concurrent/atomic/java_thread_local_var'
-require 'concurrent/utility/engine'
 
 module Concurrent
 

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/map/mri_map_backend.rb

@@ -19,7 +19,7 @@ module Concurrent
       end
 
       def compute_if_absent(key)
-        if stored_value = _get(key) # fast non-blocking path for the most likely case
+        if NULL != (stored_value = @backend.fetch(key, NULL)) # fast non-blocking path for the most likely case
           stored_value
         else
           @write_lock.synchronize { super }

data/lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb

@@ -0,0 +1,14 @@
+module Concurrent
+
+  # @!visibility private
+  module Collection
+
+    # @!visibility private
+    class TruffleRubyMapBackend < TruffleRuby::ConcurrentMap
+      def initialize(options = nil)
+        options ||= {}
+        super(initial_capacity: options[:initial_capacity], load_factor: options[:load_factor])
+      end
+    end
+  end
+end

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/non_concurrent_priority_queue.rb

@@ -1,6 +1,6 @@
+require 'concurrent/utility/engine'
 require 'concurrent/collection/java_non_concurrent_priority_queue'
 require 'concurrent/collection/ruby_non_concurrent_priority_queue'
-require 'concurrent/utility/engine'
 
 module Concurrent
   module Collection

data/lib/{concurrent → concurrent-ruby/concurrent}/collection/ruby_non_concurrent_priority_queue.rb

@@ -30,7 +30,7 @@ module Concurrent
           if @queue[k] == item
             swap(k, @length)
             @length -= 1
-            sink(k)
+            sink(k) || swim(k)
             @queue.pop
           else
             k += 1
@@ -126,12 +126,17 @@ module Concurrent
       # 
       # @!visibility private
       def sink(k)
+        success = false
+
         while (j = (2 * k)) <= @length do
           j += 1 if j < @length && ! ordered?(j, j+1)
           break if ordered?(k, j)
           swap(k, j)
+          success = true
           k = j
         end
+
+        success
       end
 
       # Percolate up to maintain heap invariant.
@@ -140,10 +145,15 @@ module Concurrent
       # 
       # @!visibility private
       def swim(k)
+        success = false
+
         while k > 1 && ! ordered?(k/2, k) do
           swap(k, k/2)
           k = k/2
+          success = true
         end
+
+        success
       end
     end
   end

data/lib/{concurrent → concurrent-ruby/concurrent}/concern/dereferenceable.rb

@@ -37,8 +37,8 @@ module Concurrent
       #   returning data to the caller (dereferencing).
       #
       #   @note Most classes that include this module will call `#set_deref_options`
-      #   from within the constructor, thus allowing these options to be set at
-      #   object creation.
+      #     from within the constructor, thus allowing these options to be set at
+      #     object creation.
       #
       #   @param [Hash] opts the options defining dereference behavior.
       #   @option opts [String] :dup_on_deref (false) call `#dup` before returning the data

data/lib/{concurrent → concurrent-ruby/concurrent}/configuration.rb

@@ -3,13 +3,14 @@ require 'concurrent/delay'
 require 'concurrent/errors'
 require 'concurrent/atomic/atomic_reference'
 require 'concurrent/concern/logging'
+require 'concurrent/concern/deprecation'
 require 'concurrent/executor/immediate_executor'
 require 'concurrent/executor/cached_thread_pool'
-require 'concurrent/utility/at_exit'
 require 'concurrent/utility/processor_counter'
 
 module Concurrent
   extend Concern::Logging
+  extend Concern::Deprecation
 
   autoload :Options, 'concurrent/options'
   autoload :TimerSet, 'concurrent/executor/timer_set'
@@ -97,15 +98,15 @@ module Concurrent
   end
 
   # @!visibility private
-  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor(auto_terminate: true) }
+  GLOBAL_FAST_EXECUTOR = Delay.new { Concurrent.new_fast_executor }
   private_constant :GLOBAL_FAST_EXECUTOR
 
   # @!visibility private
-  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor(auto_terminate: true) }
+  GLOBAL_IO_EXECUTOR = Delay.new { Concurrent.new_io_executor }
   private_constant :GLOBAL_IO_EXECUTOR
 
   # @!visibility private
-  GLOBAL_TIMER_SET = Delay.new { TimerSet.new(auto_terminate: true) }
+  GLOBAL_TIMER_SET = Delay.new { TimerSet.new }
   private_constant :GLOBAL_TIMER_SET
 
   # @!visibility private
@@ -115,7 +116,7 @@ module Concurrent
   # Disables AtExit handlers including pool auto-termination handlers.
   # When disabled it will be the application programmer's responsibility
   # to ensure that the handlers are shutdown properly prior to application
-  # exit by calling {AtExit.run} method.
+  # exit by calling `AtExit.run` method.
   #
   # @note this option should be needed only because of `at_exit` ordering
   #   issues which may arise when running some of the testing frameworks.
@@ -125,9 +126,10 @@ module Concurrent
   # @note This method should *never* be called
   #   from within a gem. It should *only* be used from within the main
   #   application and even then it should be used only when necessary.
-  # @see AtExit
+  # @deprecated Has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841.
+  #
   def self.disable_at_exit_handlers!
-    AtExit.enabled = false
+    deprecated "Method #disable_at_exit_handlers! has no effect since it is no longer needed, see https://github.com/ruby-concurrency/concurrent-ruby/pull/841."
   end
 
   # Global thread pool optimized for short, fast *operations*.
@@ -171,14 +173,16 @@ module Concurrent
         auto_terminate:  opts.fetch(:auto_terminate, true),
         idletime:        60, # 1 minute
         max_queue:       0, # unlimited
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "fast"
     )
   end
 
   def self.new_io_executor(opts = {})
     CachedThreadPool.new(
         auto_terminate:  opts.fetch(:auto_terminate, true),
-        fallback_policy: :abort # shouldn't matter -- 0 max queue
+        fallback_policy: :abort, # shouldn't matter -- 0 max queue
+        name:            "io"
     )
   end
 end