concurrent-ruby 1.3.4 → 1.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 01c9677c137013ec86d98778a4aa6a9e69bca9b0ae29e923a37254c9cdc515fe
-  data.tar.gz: 3be169b6d0a11914f85e4a0e1221cd5c122bd59035abe9718892e1a3b4bc690b
+  metadata.gz: e27f11f8dd5047c9ca365ca8babf3241defab1d707be5055720d1b905e5aa188
+  data.tar.gz: 3c5c5e998d8bd76b3b1faf813b870e779d9546149bb6a88a229659dfd741dd13
 SHA512:
-  metadata.gz: 89544dfc5575906cac0f5c57ce5348b944a70a6f77154fb70d0f185b9cc79344a5bb5147a7cf22808e071b4213c80c94e3036b98a2f4102018daf8ba16492db8
-  data.tar.gz: f084a5a9aa8c6e2ad305fe360f1e8e3b264ad0b45f7add6c04561ff4945cbf0b7c30b2c0d6801be46bc61b3f22f60975e8397973a321268bbf302f4bcb65ab24
+  metadata.gz: c5cf562bf20ba3f20c5ed974a90b55d5f9f08e70fb4af2b722b296ebc1f2726daf431b7410199f19b310b22da260d85d6508c472ef59356903b51ab1123d4d1d
+  data.tar.gz: e187fd07e9e10852e408a6c371be9b734b1821fbc42b7c820440caafa5febef3786cf4fd473bd81f1e28c59e1cb4f177ebeec47ef913ed9445425003022c0a65

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## Current
 
+## Release v1.3.6 (13 December 2025)
+
+concurrent-ruby:
+
+* See the [release notes on GitHub](https://github.com/ruby-concurrency/concurrent-ruby/releases/tag/v1.3.6).
+
+## Release v1.3.5, edge v0.7.2 (15 January 2025)
+
+concurrent-ruby:
+
+* (#1062) Remove dependency on logger.
+
+concurrent-ruby-edge:
+
+* (#1062) Remove dependency on logger.
+
 ## Release v1.3.4 (10 August 2024)
 
 * (#1060) Fix bug with return value of `Concurrent.available_processor_count` when `cpu.cfs_quota_us` is -1.
@@ -296,7 +312,7 @@ concurrent-ruby-edge:
 * Simplification of `RubySingleThreadExecutor`
 * `Async` improvements
   - Each object uses its own `SingleThreadExecutor` instead of the global thread pool.
-  - No longers supports executor injection
+  - No longer supports executor injection
   - Much better documentation
 * `Atom` updates
   - No longer `Dereferenceable`
@@ -471,7 +487,7 @@ Please see the [roadmap](https://github.com/ruby-concurrency/concurrent-ruby/iss
 * Fixed bug with return value of `Concurrent::Actor::Utils::Pool#ask`
 * Fixed timing bug in `TimerTask`
 * Fixed bug when creating a `JavaThreadPoolExecutor` with minimum pool size of zero
-* Removed confusing warning when not using native extenstions
+* Removed confusing warning when not using native extensions
 * Improved documentation
 
 ## Release v0.7.0 (13 August 2014)

data/README.md

@@ -207,7 +207,7 @@ Deprecated features are still available and bugs are being fixed, but new featur
 These are available in the `concurrent-ruby-edge` companion gem.
 
 These features are under active development and may change frequently. They are expected not to
-keep backward compatibility (there may also lack tests and documentation). Semantic versions will
+keep backward compatibility (they may also lack tests and documentation). Semantic versions will
 be obeyed though. Features developed in `concurrent-ruby-edge` are expected to move to
 `concurrent-ruby` when final.
 
@@ -284,7 +284,7 @@ To use the tools in the Edge gem it must be required separately:
 require 'concurrent-edge'
 ```
 
-If the library does not behave as expected, `Concurrent.use_stdlib_logger(Logger::DEBUG)` could 
+If the library does not behave as expected, `Concurrent.use_simple_logger(:DEBUG)` could
 help to reveal the problem.
 
 ## Installation
@@ -358,7 +358,8 @@ best practice is to depend on `concurrent-ruby` and let users to decide if they
 * Recent CRuby
 * JRuby, `rbenv install jruby-9.2.17.0`
 * Set env variable `CONCURRENT_JRUBY_HOME` to point to it, e.g. `/usr/local/opt/rbenv/versions/jruby-9.2.17.0`
-* Install Docker, required for Windows builds
+* Install Docker or Podman, required for Windows builds
+* If `bundle config get path` is set, use `bundle config set --local path.system true` otherwise the `gem name, path: '.'` gems won't be found (Bundler limitation).
 
 ### Publishing the Gem
 
@@ -378,6 +379,7 @@ best practice is to depend on `concurrent-ruby` and let users to decide if they
 * [Charles Oliver Nutter](https://github.com/headius)
 * [Ben Sheldon](https://github.com/bensheldon)
 * [Samuel Williams](https://github.com/ioquatix)
+* [Joshua Young](https://github.com/joshuay03)
 
 ### Special Thanks to
 

data/Rakefile

@@ -12,6 +12,8 @@ ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME']
 Rake::JavaExtensionTask.new('concurrent_ruby', core_gemspec) do |ext|
   ext.ext_dir = 'ext/concurrent-ruby'
   ext.lib_dir = 'lib/concurrent-ruby/concurrent'
+  ext.source_version = '8'
+  ext.target_version = '8'
 end
 
 if RUBY_ENGINE == 'ruby'

data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/ConcurrentHashMapV8.java

@@ -481,7 +481,7 @@ public class ConcurrentHashMapV8<K, V>
      *
      * Maintaining API and serialization compatibility with previous
      * versions of this class introduces several oddities. Mainly: We
-     * leave untouched but unused constructor arguments refering to
+     * leave untouched but unused constructor arguments referring to
      * concurrencyLevel. We accept a loadFactor constructor argument,
      * but apply it only to initial table capacity (which is the only
      * time that we can guarantee to honor it.) We also declare an

data/ext/concurrent-ruby/com/concurrent_ruby/ext/jsr166e/nounsafe/ConcurrentHashMapV8.java

@@ -484,7 +484,7 @@ public class ConcurrentHashMapV8<K, V>
      *
      * Maintaining API and serialization compatibility with previous
      * versions of this class introduces several oddities. Mainly: We
-     * leave untouched but unused constructor arguments refering to
+     * leave untouched but unused constructor arguments referring to
      * concurrencyLevel. We accept a loadFactor constructor argument,
      * but apply it only to initial table capacity (which is the only
      * time that we can guarantee to honor it.) We also declare an

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

@@ -371,7 +371,7 @@ module Concurrent
     # @param [Float] timeout the maximum number of seconds to wait
     # @return [Boolean] true if all actions complete before timeout
     #
-    # @raise [Concurrent::TimeoutError] when timout is reached
+    # @raise [Concurrent::TimeoutError] when timeout is reached
     #
     # @!macro agent_await_warning
     def await_for!(timeout)
@@ -477,7 +477,7 @@ module Concurrent
       # @param [Array<Concurrent::Agent>] agents the Agents on which to wait
       # @return [Boolean] true if all actions complete before timeout
       #
-      # @raise [Concurrent::TimeoutError] when timout is reached
+      # @raise [Concurrent::TimeoutError] when timeout is reached
       # @!macro agent_await_warning
       def await_for!(timeout, *agents)
         raise Concurrent::TimeoutError unless await_for(timeout, *agents)

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

@@ -218,7 +218,7 @@ module Concurrent
 
     # @!method self.new(*args, &block)
     #
-    #   Instanciate a new object and ensure proper initialization of the
+    #   Instantiate a new object and ensure proper initialization of the
     #   synchronization mechanisms.
     #
     #   @param [Array<Object>] args Zero or more arguments to be passed to the

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

@@ -113,7 +113,7 @@ module Concurrent
     # @option opts [Proc] :validator (nil) Optional proc used to validate new
     #   values. It must accept one and only one argument which will be the
     #   intended new value. The validator will return true if the new value
-    #   is acceptable else return false (preferrably) or raise an exception.
+    #   is acceptable else return false (preferably) or raise an exception.
     #
     # @!macro deref_options
     #

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

@@ -6,6 +6,7 @@ module Concurrent
   # @!visibility private
   def self.mutex_owned_per_thread?
     return false if Concurrent.on_jruby? || Concurrent.on_truffleruby?
+    return RUBY_VERSION < "3.0" if Concurrent.on_cruby?
 
     mutex = Mutex.new
     # Lock the mutex:

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

@@ -0,0 +1,55 @@
+module Concurrent
+  module Collection
+    # @!visibility private
+    # @!macro ruby_timeout_queue
+    class RubyTimeoutQueue < ::Queue
+      def initialize(*args)
+        if RUBY_VERSION >= '3.2'
+          raise "#{self.class.name} is not needed on Ruby 3.2 or later, use ::Queue instead"
+        end
+
+        super(*args)
+
+        @mutex = Mutex.new
+        @cond_var = ConditionVariable.new
+      end
+
+      def push(obj)
+        @mutex.synchronize do
+          super(obj)
+          @cond_var.signal
+        end
+      end
+      alias_method :enq, :push
+      alias_method :<<, :push
+
+      def pop(non_block = false, timeout: nil)
+        if non_block && timeout
+          raise ArgumentError, "can't set a timeout if non_block is enabled"
+        end
+
+        if non_block
+          super(true)
+        elsif timeout
+          @mutex.synchronize do
+            deadline = Concurrent.monotonic_time + timeout
+            while (now = Concurrent.monotonic_time) < deadline && empty?
+              @cond_var.wait(@mutex, deadline - now)
+            end
+            begin
+              return super(true)
+            rescue ThreadError
+              # still empty
+              nil
+            end
+          end
+        else
+          super(false)
+        end
+      end
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+    end
+    private_constant :RubyTimeoutQueue
+  end
+end

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

@@ -0,0 +1,18 @@
+module Concurrent
+  module Collection
+    # @!visibility private
+    # @!macro internal_implementation_note
+    TimeoutQueueImplementation = if RUBY_VERSION >= '3.2'
+                                   ::Queue
+                                 else
+                                   require 'concurrent/collection/ruby_timeout_queue'
+                                   RubyTimeoutQueue
+                                 end
+    private_constant :TimeoutQueueImplementation
+
+    # @!visibility private
+    # @!macro timeout_queue
+    class TimeoutQueue < TimeoutQueueImplementation
+    end
+  end
+end

data/lib/concurrent-ruby/concurrent/concern/logging.rb

@@ -1,4 +1,3 @@
-require 'logger'
 require 'concurrent/atomic/atomic_reference'
 
 module Concurrent
@@ -8,10 +7,12 @@ module Concurrent
     #
     # @!visibility private
     module Logging
-      include Logger::Severity
+      # The same as Logger::Severity but we copy it here to avoid a dependency on the logger gem just for these 7 constants
+      DEBUG, INFO, WARN, ERROR, FATAL, UNKNOWN = 0, 1, 2, 3, 4, 5
+      SEV_LABEL = %w[DEBUG INFO WARN ERROR FATAL ANY].freeze
 
       # Logs through {Concurrent.global_logger}, it can be overridden by setting @logger
-      # @param [Integer] level one of Logger::Severity constants
+      # @param [Integer] level one of Concurrent::Concern::Logging constants
       # @param [String] progname e.g. a path of an Actor
       # @param [String, nil] message when nil block is used to generate the message
       # @yieldreturn [String] a message
@@ -23,7 +24,7 @@ module Concurrent
                  end
         logger.call level, progname, message, &block
       rescue => error
-        $stderr.puts "`Concurrent.configuration.logger` failed to log #{[level, progname, message, block]}\n" +
+        $stderr.puts "`Concurrent.global_logger` failed to log #{[level, progname, message, block]}\n" +
           "#{error.message} (#{error.class})\n#{error.backtrace.join "\n"}"
       end
     end
@@ -33,8 +34,10 @@ end
 module Concurrent
   extend Concern::Logging
 
-  # @return [Logger] Logger with provided level and output.
-  def self.create_simple_logger(level = Logger::FATAL, output = $stderr)
+  # Create a simple logger with provided level and output.
+  def self.create_simple_logger(level = :FATAL, output = $stderr)
+    level = Concern::Logging.const_get(level) unless level.is_a?(Integer)
+
     # TODO (pitr-ch 24-Dec-2016): figure out why it had to be replaced, stdlogger was deadlocking
     lambda do |severity, progname, message = nil, &block|
       return false if severity < level
@@ -52,7 +55,7 @@ module Concurrent
 
       output.print format "[%s] %5s -- %s: %s\n",
                           Time.now.strftime('%Y-%m-%d %H:%M:%S.%L'),
-                          Logger::SEV_LABEL[severity],
+                          Concern::Logging::SEV_LABEL[severity],
                           progname,
                           formatted_message
       true
@@ -60,13 +63,15 @@ module Concurrent
   end
 
   # Use logger created by #create_simple_logger to log concurrent-ruby messages.
-  def self.use_simple_logger(level = Logger::FATAL, output = $stderr)
+  def self.use_simple_logger(level = :FATAL, output = $stderr)
     Concurrent.global_logger = create_simple_logger level, output
   end
 
-  # @return [Logger] Logger with provided level and output.
+  # Create a stdlib logger with provided level and output.
+  # If you use this deprecated method you might need to add logger to your Gemfile to avoid warnings from Ruby 3.3.5+.
   # @deprecated
-  def self.create_stdlib_logger(level = Logger::FATAL, output = $stderr)
+  def self.create_stdlib_logger(level = :FATAL, output = $stderr)
+    require 'logger'
     logger           = Logger.new(output)
     logger.level     = level
     logger.formatter = lambda do |severity, datetime, progname, msg|
@@ -93,7 +98,7 @@ module Concurrent
 
   # Use logger created by #create_stdlib_logger to log concurrent-ruby messages.
   # @deprecated
-  def self.use_stdlib_logger(level = Logger::FATAL, output = $stderr)
+  def self.use_stdlib_logger(level = :FATAL, output = $stderr)
     Concurrent.global_logger = create_stdlib_logger level, output
   end
 
@@ -103,7 +108,7 @@ module Concurrent
   NULL_LOGGER   = lambda { |level, progname, message = nil, &block| }
 
   # @!visibility private
-  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(Logger::WARN))
+  GLOBAL_LOGGER = AtomicReference.new(create_simple_logger(:WARN))
   private_constant :GLOBAL_LOGGER
 
   def self.global_logger

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

@@ -19,7 +19,7 @@ module Concurrent
   #
   # When a `Delay` is created its state is set to `pending`. The value and
   # reason are both `nil`. The first time the `#value` method is called the
-  # enclosed opration will be run and the calling thread will block. Other
+  # enclosed operation will be run and the calling thread will block. Other
   # threads attempting to call `#value` will block as well. Once the operation
   # is complete the *value* will be set to the result of the operation or the
   # *reason* will be set to the raised exception, as appropriate. All threads

data/lib/concurrent-ruby/concurrent/executor/fixed_thread_pool.rb

@@ -81,10 +81,8 @@ module Concurrent
   #   What is being pruned is controlled by the min_threads and idletime
   #   parameters passed at pool creation time
   #
-  #   This is a no-op on some pool implementation (e.g. the Java one).  The Ruby
-  #   pool will auto-prune each time a new job is posted. You will need to call
-  #   this method explicitely in case your application post jobs in bursts (a
-  #   lot of jobs and then nothing for long periods)
+  #   This is a no-op on all pool implementations as they prune themselves
+  #   automatically, and has been deprecated.
 
   # @!macro thread_pool_executor_public_api
   #

data/lib/concurrent-ruby/concurrent/executor/java_executor_service.rb

@@ -46,6 +46,7 @@ if Concurrent.on_jruby?
       def kill
         synchronize do
           @executor.shutdownNow
+          wait_for_termination
           nil
         end
       end

data/lib/concurrent-ruby/concurrent/executor/java_thread_pool_executor.rb

@@ -8,6 +8,7 @@ if Concurrent.on_jruby?
     # @!macro thread_pool_options
     # @!visibility private
     class JavaThreadPoolExecutor < JavaExecutorService
+      include Concern::Deprecation
 
       # @!macro thread_pool_executor_constant_default_max_pool_size
       DEFAULT_MAX_POOL_SIZE = java.lang.Integer::MAX_VALUE # 2147483647
@@ -100,6 +101,7 @@ if Concurrent.on_jruby?
 
       # @!macro thread_pool_executor_method_prune_pool
       def prune_pool
+        deprecated "#prune_pool has no effect and will be removed in the next release."
       end
 
       private

data/lib/concurrent-ruby/concurrent/executor/ruby_single_thread_executor.rb

@@ -1,4 +1,5 @@
 require 'concurrent/executor/ruby_thread_pool_executor'
+require 'concurrent/executor/serial_executor_service'
 
 module Concurrent
 
@@ -6,6 +7,7 @@ module Concurrent
   # @!macro abstract_executor_service_public_api
   # @!visibility private
   class RubySingleThreadExecutor < RubyThreadPoolExecutor
+    include SerialExecutorService
 
     # @!macro single_thread_executor_method_initialize
     def initialize(opts = {})

data/lib/concurrent-ruby/concurrent/executor/ruby_thread_pool_executor.rb

@@ -3,6 +3,7 @@ require 'concurrent/atomic/event'
 require 'concurrent/concern/logging'
 require 'concurrent/executor/ruby_executor_service'
 require 'concurrent/utility/monotonic_time'
+require 'concurrent/collection/timeout_queue'
 
 module Concurrent
 
@@ -10,6 +11,7 @@ module Concurrent
   # @!macro thread_pool_options
   # @!visibility private
   class RubyThreadPoolExecutor < RubyExecutorService
+    include Concern::Deprecation
 
     # @!macro thread_pool_executor_constant_default_max_pool_size
     DEFAULT_MAX_POOL_SIZE      = 2_147_483_647 # java.lang.Integer::MAX_VALUE
@@ -94,9 +96,28 @@ module Concurrent
       end
     end
 
+    # removes the worker if it can be pruned
+    #
+    # @return [true, false] if the worker was pruned
+    #
     # @!visibility private
-    def remove_busy_worker(worker)
-      synchronize { ns_remove_busy_worker worker }
+    def prune_worker(worker)
+      synchronize do
+        if ns_prunable_capacity > 0
+          remove_worker worker
+          true
+        else
+          false
+        end
+      end
+    end
+
+    # @!visibility private
+    def remove_worker(worker)
+      synchronize do
+        ns_remove_ready_worker worker
+        ns_remove_busy_worker worker
+      end
     end
 
     # @!visibility private
@@ -116,7 +137,7 @@ module Concurrent
 
     # @!macro thread_pool_executor_method_prune_pool
     def prune_pool
-      synchronize { ns_prune_pool }
+      deprecated "#prune_pool has no effect and will be removed in next the release, see https://github.com/ruby-concurrency/concurrent-ruby/pull/1082."
     end
 
     private
@@ -146,9 +167,6 @@ module Concurrent
       @largest_length       = 0
       @workers_counter      = 0
       @ruby_pid             = $$ # detects if Ruby has forked
-
-      @gc_interval  = opts.fetch(:gc_interval, @idletime / 2.0).to_i # undocumented
-      @next_gc_time = Concurrent.monotonic_time + @gc_interval
     end
 
     # @!visibility private
@@ -162,12 +180,10 @@ module Concurrent
 
       if ns_assign_worker(*args, &task) || ns_enqueue(*args, &task)
         @scheduled_task_count += 1
+        nil
       else
-        return fallback_action(*args, &task)
+        fallback_action(*args, &task)
       end
-
-      ns_prune_pool if @next_gc_time < Concurrent.monotonic_time
-      nil
     end
 
     # @!visibility private
@@ -218,7 +234,7 @@ module Concurrent
     # @!visibility private
     def ns_enqueue(*args, &task)
       return false if @synchronous
-      
+
       if !ns_limited_queue? || @queue.size < @max_queue
         @queue << [task, args]
         true
@@ -265,7 +281,7 @@ module Concurrent
       end
     end
 
-    # removes a worker which is not in not tracked in @ready
+    # removes a worker which is not tracked in @ready
     #
     # @!visibility private
     def ns_remove_busy_worker(worker)
@@ -274,25 +290,27 @@ module Concurrent
       true
     end
 
-    # try oldest worker if it is idle for enough time, it's returned back at the start
-    #
     # @!visibility private
-    def ns_prune_pool
-      now = Concurrent.monotonic_time
-      stopped_workers = 0
-      while !@ready.empty? && (@pool.size - stopped_workers > @min_length)
-        worker, last_message = @ready.first
-        if now - last_message > self.idletime
-          stopped_workers += 1
-          @ready.shift
-          worker << :stop
-        else break
-        end
+    def ns_remove_ready_worker(worker)
+      if index = @ready.index { |rw, _| rw == worker }
+        @ready.delete_at(index)
       end
+      true
+    end
 
-      @next_gc_time = Concurrent.monotonic_time + @gc_interval
+    # @return [Integer] number of excess idle workers which can be removed without
+    #                   going below min_length, or all workers if not running
+    #
+    # @!visibility private
+    def ns_prunable_capacity
+      if running?
+        [@pool.size - @min_length, @ready.size].min
+      else
+        @pool.size
+      end
     end
 
+    # @!visibility private
     def ns_reset_if_forked
       if $$ != @ruby_pid
         @queue.clear
@@ -312,7 +330,7 @@ module Concurrent
 
       def initialize(pool, id)
         # instance variables accessed only under pool's lock so no need to sync here again
-        @queue  = Queue.new
+        @queue  = Collection::TimeoutQueue.new
         @pool   = pool
         @thread = create_worker @queue, pool, pool.idletime
 
@@ -338,17 +356,22 @@ module Concurrent
       def create_worker(queue, pool, idletime)
         Thread.new(queue, pool, idletime) do |my_queue, my_pool, my_idletime|
           catch(:stop) do
-            loop do
+            prunable = true
 
-              case message = my_queue.pop
+            loop do
+              timeout = prunable && my_pool.running? ? my_idletime : nil
+              case message = my_queue.pop(timeout: timeout)
+              when nil
+                throw :stop if my_pool.prune_worker(self)
+                prunable = false
               when :stop
-                my_pool.remove_busy_worker(self)
+                my_pool.remove_worker(self)
                 throw :stop
-
               else
                 task, args = message
                 run_task my_pool, task, args
                 my_pool.ready_worker(self, Concurrent.monotonic_time)
+                prunable = true
               end
             end
           end

data/lib/concurrent-ruby/concurrent/executor/single_thread_executor.rb

@@ -27,7 +27,7 @@ module Concurrent
   #   is received. This pattern has several issues. The thread itself is highly
   #   susceptible to errors during processing. Also, the thread itself must be
   #   constantly monitored and restarted should it die. `SingleThreadExecutor`
-  #   encapsulates all these bahaviors. The task processor is highly resilient
+  #   encapsulates all these behaviors. The task processor is highly resilient
   #   to errors from within tasks. Also, should the thread die it will
   #   automatically be restarted.
   #

data/lib/concurrent-ruby/concurrent/executor/timer_set.rb

@@ -61,6 +61,7 @@ module Concurrent
     # not running.
     def kill
       shutdown
+      @timer_executor.kill
     end
 
     private :<<
@@ -122,7 +123,9 @@ module Concurrent
     def ns_shutdown_execution
       ns_reset_if_forked
       @queue.clear
-      @timer_executor.kill
+      @condition.set
+      @condition.reset
+      @timer_executor.shutdown
       stopped_event.set
     end
 

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

@@ -10,7 +10,6 @@ require 'concurrent/executor/java_thread_pool_executor'
 require 'concurrent/executor/ruby_executor_service'
 require 'concurrent/executor/ruby_single_thread_executor'
 require 'concurrent/executor/ruby_thread_pool_executor'
-require 'concurrent/executor/cached_thread_pool'
 require 'concurrent/executor/safe_task_executor'
 require 'concurrent/executor/serial_executor_service'
 require 'concurrent/executor/serialized_execution'

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

@@ -148,7 +148,7 @@ module Concurrent
         if value = super # non-falsy value is an existing mapping, return it right away
           value
           # re-check is done with get_or_default(key, NULL) instead of a simple !key?(key) in order to avoid a race condition, whereby by the time the current thread gets to the key?(key) call
-          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrent +nil+ value
+          # a key => value mapping might have already been created by a different thread (key?(key) would then return true, this elsif branch wouldn't be taken and an incorrect +nil+ value
           # would be returned)
           # note: nil == value check is not technically necessary
         elsif @default_proc && nil == value && NULL == (value = get_or_default(key, NULL))

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

@@ -9,7 +9,7 @@ module Concurrent
   # queue of length one, or a special kind of mutable variable.
   #
   # On top of the fundamental `#put` and `#take` operations, we also provide a
-  # `#mutate` that is atomic with respect to operations on the same instance.
+  # `#modify` that is atomic with respect to operations on the same instance.
   # These operations all support timeouts.
   #
   # We also support non-blocking operations `#try_put!` and `#try_take!`, a
@@ -87,7 +87,7 @@ module Concurrent
       @mutex.synchronize do
         wait_for_full(timeout)
 
-        # if we timeoud out we'll still be empty
+        # If we timed out we'll still be empty
         if unlocked_full?
           yield @value
         else
@@ -116,10 +116,10 @@ module Concurrent
     end
 
     # Atomically `take`, yield the value to a block for transformation, and then
-    # `put` the transformed value. Returns the transformed value. A timeout can
+    # `put` the transformed value. Returns the pre-transform value. A timeout can
     # be set to limit the time spent blocked, in which case it returns `TIMEOUT`
     # if the time is exceeded.
-    # @return [Object] the transformed value, or `TIMEOUT`
+    # @return [Object] the pre-transform value, or `TIMEOUT`
     def modify(timeout = nil)
       raise ArgumentError.new('no block given') unless block_given?
 

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

@@ -103,7 +103,7 @@ module Concurrent
   # - if parent is *rejected* the child will be *pending* (but will ultimately be *rejected*)
   #
   # Promises are executed asynchronously from the main thread. By the time a
-  # child Promise finishes intialization it may be in a different state than its
+  # child Promise finishes initialization it may be in a different state than its
   # parent (by the time a child is created its parent may have completed
   # execution and changed state). Despite being asynchronous, however, the order
   # of execution of Promise objects in a chain (or tree) is strictly defined.
@@ -167,7 +167,7 @@ module Concurrent
   # c2 = p.then(-> reason { raise 'Boom!' })
   #
   # c1.wait.state  #=> :fulfilled
-  # c1.value       #=> 45
+  # c1.value       #=> 42
   # c2.wait.state  #=> :rejected
   # c2.reason      #=> #<RuntimeError: Boom!>
   # ```

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

@@ -193,7 +193,7 @@ module Concurrent
       end
     end
 
-    # The `delay` value given at instanciation.
+    # The `delay` value given at instantiation.
     #
     # @return [Float] the initial delay.
     def initial_delay

data/lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb

@@ -157,7 +157,7 @@ module Concurrent
           end
         end
         members.each_with_index do |member, index|
-          clazz.send :remove_method, member if clazz.instance_methods.include? member
+          clazz.send :remove_method, member if clazz.instance_methods(false).include? member
           clazz.send(:define_method, member) do
             @values[index]
           end

data/lib/concurrent-ruby/concurrent/synchronization/object.rb

@@ -58,7 +58,7 @@ module Concurrent
 
       # Creates methods for reading and writing to a instance variable with
       # volatile (Java) semantic as {.attr_volatile} does.
-      # The instance variable should be accessed oly through generated methods.
+      # The instance variable should be accessed only through generated methods.
       # This method generates following methods: `value`, `value=(new_value) #=> new_value`,
       # `swap_value(new_value) #=> old_value`,
       # `compare_and_set_value(expected, value) #=> true || false`, `update_value(&block)`.

data/lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb

@@ -9,7 +9,7 @@ module Concurrent
     # @!visibility private
     module Util
 
-      # A Ruby port of the Doug Lea's jsr166e.LondAdder class version 1.8
+      # A Ruby port of the Doug Lea's jsr166e.LongAdder class version 1.8
       # available in public domain.
       #
       # Original source code available here:

data/lib/concurrent-ruby/concurrent/thread_safe/util/xor_shift_random.rb

@@ -15,7 +15,7 @@ module Concurrent
       # Usage:
       #   x = XorShiftRandom.get # uses Kernel.rand to generate an initial seed
       #   while true
-      #     if (x = XorShiftRandom.xorshift).odd? # thread-localy generate a next random number
+      #     if (x = XorShiftRandom.xorshift).odd? # thread-locally generate a next random number
       #       do_something_at_random
       #     end
       #   end

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

@@ -2,6 +2,7 @@ require 'concurrent/collection/copy_on_notify_observer_set'
 require 'concurrent/concern/dereferenceable'
 require 'concurrent/concern/observable'
 require 'concurrent/atomic/atomic_boolean'
+require 'concurrent/atomic/atomic_fixnum'
 require 'concurrent/executor/executor_service'
 require 'concurrent/executor/ruby_executor_service'
 require 'concurrent/executor/safe_task_executor'
@@ -236,6 +237,7 @@ module Concurrent
       synchronize do
         if @running.false?
           @running.make_true
+          @age.increment
           schedule_next_task(@run_now ? 0 : @execution_interval)
         end
       end
@@ -309,6 +311,7 @@ module Concurrent
       @task = Concurrent::SafeTaskExecutor.new(task)
       @executor = opts[:executor] || Concurrent.global_io_executor
       @running = Concurrent::AtomicBoolean.new(false)
+      @age = Concurrent::AtomicFixnum.new(0)
       @value = nil
 
       self.observers = Collection::CopyOnNotifyObserverSet.new
@@ -328,13 +331,15 @@ module Concurrent
 
     # @!visibility private
     def schedule_next_task(interval = execution_interval)
-      ScheduledTask.execute(interval, executor: @executor, args: [Concurrent::Event.new], &method(:execute_task))
+      ScheduledTask.execute(interval, executor: @executor, args: [Concurrent::Event.new, @age.value], &method(:execute_task))
       nil
     end
 
     # @!visibility private
-    def execute_task(completion)
+    def execute_task(completion, age_when_scheduled)
       return nil unless @running.true?
+      return nil unless @age.value == age_when_scheduled
+
       start_time = Concurrent.monotonic_time
       _success, value, reason = @task.execute(self)
       if completion.try?

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

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '1.3.4'
+  VERSION = '1.3.6'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.3.4
+  version: 1.3.6
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-10 00:00:00.000000000 Z
+date: 2025-12-13 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -82,6 +82,8 @@ files:
 - lib/concurrent-ruby/concurrent/collection/map/truffleruby_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/non_concurrent_priority_queue.rb
 - lib/concurrent-ruby/concurrent/collection/ruby_non_concurrent_priority_queue.rb
+- lib/concurrent-ruby/concurrent/collection/ruby_timeout_queue.rb
+- lib/concurrent-ruby/concurrent/collection/timeout_queue.rb
 - lib/concurrent-ruby/concurrent/concern/deprecation.rb
 - lib/concurrent-ruby/concurrent/concern/dereferenceable.rb
 - lib/concurrent-ruby/concurrent/concern/logging.rb
@@ -181,7 +183,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.3.27
 signing_key: 
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,