concurrent-ruby 1.3.5 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14d5a264c6fdc7b6087131a0f0a2fc1ce661d18029440e426e094443eb359ca6
-  data.tar.gz: 42e7b1b8fb885aec9b7b08488c6682af2743e65ad6dcd731f8c86d34f7768981
+  metadata.gz: 0d094624e5f9f2dffc45b80892987f339d8b8c09ff2f01cf923e3825dd6409f7
+  data.tar.gz: 02adb496e81a3adb7e3c6042f72ec421677851033d57eb77b0e1b3641ef70684
 SHA512:
-  metadata.gz: 31b6cf4fcc533349681610e74f6261c95e5c664583014d86101578f0380a6889288b29a89314a5da59e92cd422bcd97783c34d99c3e5c21a90db0f0d3fcc57e1
-  data.tar.gz: 4438de87d8ec3ff1cc6d7d246821002bbb76d5a9ddd8b77ebf4a15c0449f1509d694c4f57936b1e1a69e19f32736f21518fd8e82b8cdfbb99d5e2948976c230e
+  metadata.gz: 43a4af037c64d4ee8e128963db7a3f40213a45898289bb9143aa222e5664982b8c0fa08d2dae8e629fa7766be6a528b74b5ba17fbbb5cb741a9b5c08020eea15
+  data.tar.gz: 0203e085d78340af99c8d8cbf2f0aa8793db6bfdbe4c25cd2ff622816581004c2871851c621d23bcfd653be30fd3aca682e98a3117b64e5735d23bb2a3bfb4c0

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## Current
 
+## Release v1.3.7 (16 June 2026)
+
+concurrent-ruby:
+
+* See the [release notes on GitHub](https://github.com/ruby-concurrency/concurrent-ruby/releases/tag/v1.3.7).
+
+## 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:

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.
 
@@ -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

@@ -335,9 +335,8 @@ namespace :release do
 
     desc '** print post release steps'
     task :post_steps do
-      # TODO: (petr 05-Jun-2021) automate and renew the process
-      puts 'Manually: create a release on GitHub with relevant changelog part'
-      puts 'Manually: send email same as release with relevant changelog part'
+      puts
+      puts 'Manually: create a release on GitHub, use the "Generate release notes" button'
       puts 'Manually: tweet'
     end
   end

data/ext/concurrent-ruby/com/concurrent_ruby/ext/AtomicReferenceLibrary.java

@@ -1,12 +1,12 @@
 package com.concurrent_ruby.ext;
 
+import static org.jruby.runtime.Visibility.PRIVATE;
+
 import java.lang.reflect.Field;
 import java.io.IOException;
-import java.util.concurrent.atomic.AtomicReferenceFieldUpdater;
 import org.jruby.Ruby;
 import org.jruby.RubyClass;
 import org.jruby.RubyModule;
-import org.jruby.RubyNumeric;
 import org.jruby.RubyObject;
 import org.jruby.anno.JRubyClass;
 import org.jruby.anno.JRubyMethod;
@@ -91,15 +91,9 @@ public class AtomicReferenceLibrary implements Library {
             return newValue;
         }
 
-        @JRubyMethod(name = {"compare_and_set", "compare_and_swap"})
+        @JRubyMethod(name = "_compare_and_set", visibility = PRIVATE)
         public IRubyObject compare_and_set(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
             Ruby runtime = context.runtime;
-            
-            if (expectedValue instanceof RubyNumeric) {
-                // numerics are not always idempotent in Ruby, so we need to do slower logic
-                return compareAndSetNumeric(context, expectedValue, newValue);
-            }
-            
             return runtime.newBoolean(UNSAFE.compareAndSwapObject(this, referenceOffset, expectedValue, newValue));
         }
 
@@ -113,35 +107,6 @@ public class AtomicReferenceLibrary implements Library {
                 }
             }
         }
-        
-        private IRubyObject compareAndSetNumeric(ThreadContext context, IRubyObject expectedValue, IRubyObject newValue) {
-            Ruby runtime = context.runtime;
-            
-            // loop until:
-            // * reference CAS would succeed for same-valued objects
-            // * current and expected have different values as determined by #equals
-            while (true) {
-                IRubyObject current = reference;
-
-                if (!(current instanceof RubyNumeric)) {
-                    // old value is not numeric, CAS fails
-                    return runtime.getFalse();
-                }
-
-                RubyNumeric currentNumber = (RubyNumeric)current;
-                if (!currentNumber.equals(expectedValue)) {
-                    // current number does not equal expected, fail CAS
-                    return runtime.getFalse();
-                }
-
-                // check that current has not changed, or else allow loop to repeat
-                boolean success = UNSAFE.compareAndSwapObject(this, referenceOffset, current, newValue);
-                if (success) {
-                    // value is same and did not change in interim...success
-                    return runtime.getTrue();
-                }
-            }
-        }
     }
 
     private static final class UnsafeHolder {

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

@@ -22,7 +22,6 @@ module Concurrent
                                     class CAtomicReference
                                       include AtomicDirectUpdate
                                       include AtomicNumericCompareAndSetWrapper
-                                      alias_method :compare_and_swap, :compare_and_set
                                     end
                                     CAtomicReference
                                   when Concurrent.on_jruby?
@@ -30,14 +29,22 @@ module Concurrent
                                     # @!macro internal_implementation_note
                                     class JavaAtomicReference
                                       include AtomicDirectUpdate
+                                      include AtomicNumericCompareAndSetWrapper
                                     end
                                     JavaAtomicReference
                                   when Concurrent.on_truffleruby?
                                     class TruffleRubyAtomicReference < TruffleRuby::AtomicReference
                                       include AtomicDirectUpdate
+                                      if private_method_defined?(:compare_and_set_reference)
+                                        alias_method :_compare_and_set, :compare_and_set_reference
+                                        private :_compare_and_set
+                                        include AtomicNumericCompareAndSetWrapper
+                                      else
+                                        # AtomicNumericCompareAndSetWrapper behavior already in TruffleRuby::AtomicReference
+                                        alias_method :compare_and_swap, :compare_and_set
+                                      end
                                       alias_method :value, :get
                                       alias_method :value=, :set
-                                      alias_method :compare_and_swap, :compare_and_set
                                       alias_method :swap, :get_and_set
                                     end
                                     TruffleRubyAtomicReference

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/atomic/read_write_lock.rb

@@ -1,5 +1,6 @@
 require 'thread'
 require 'concurrent/atomic/atomic_fixnum'
+require 'concurrent/atomic/atomic_reference'
 require 'concurrent/errors'
 require 'concurrent/synchronization/object'
 require 'concurrent/synchronization/lock'
@@ -58,7 +59,8 @@ module Concurrent
     # Create a new `ReadWriteLock` in the unlocked state.
     def initialize
       super()
-      @Counter   = AtomicFixnum.new(0) # single integer which represents lock state
+      @Counter   = AtomicFixnum.new(0)      # single integer which represents lock state
+      @Writer    = AtomicReference.new(nil) # the thread currently holding the write lock
       @ReadLock  = Synchronization::Lock.new
       @WriteLock = Synchronization::Lock.new
     end
@@ -137,9 +139,13 @@ module Concurrent
     # Release a previously acquired read lock.
     #
     # @return [Boolean] true if the lock is successfully released
+    #
+    # @raise [Concurrent::IllegalOperationError] if no read lock is currently held.
     def release_read_lock
       while true
         c = @Counter.value
+        raise IllegalOperationError, 'Cannot release a read lock which is not held' if running_readers(c) == 0
+
         if @Counter.compare_and_set(c, c-1)
           # If one or more writers were waiting, and we were the last reader, wake a writer up
           if waiting_writer?(c) && running_readers(c) == 1
@@ -187,14 +193,21 @@ module Concurrent
           break
         end
       end
+      @Writer.set(Thread.current)
       true
     end
 
     # Release a previously acquired write lock.
     #
     # @return [Boolean] true if the lock is successfully released
+    #
+    # @raise [Concurrent::IllegalOperationError] if the write lock is not held
+    #   by the current thread.
     def release_write_lock
-      return true unless running_writer?
+      unless @Writer.compare_and_set(Thread.current, nil)
+        raise IllegalOperationError, 'Cannot release a write lock which is not held by the current thread'
+      end
+
       c = @Counter.update { |counter| counter - RUNNING_WRITER }
       @ReadLock.broadcast
       @WriteLock.signal if waiting_writers(c) > 0

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

@@ -158,9 +158,11 @@ module Concurrent
     # @return [Boolean] true if the lock is successfully acquired
     #
     # @raise [Concurrent::ResourceLimitError] if the maximum number of readers
-    #   is exceeded.
+    #   or per-thread reentrant acquires is exceeded.
     def acquire_read_lock
       if (held = @HeldCount.value) > 0
+        raise ResourceLimitError.new('Too many reader holds on this thread') if (held & READ_LOCK_MASK) == READ_LOCK_MASK
+
         # If we already have a lock, there's no need to wait
         if held & READ_LOCK_MASK == 0
           # But we do need to update the counter, if we were holding a write
@@ -212,8 +214,13 @@ module Concurrent
     # acquired immediately, return false.
     #
     # @return [Boolean] true if the lock is successfully acquired
+    #
+    # @raise [Concurrent::ResourceLimitError] if the maximum number of per-thread
+    #   reentrant acquires is exceeded.
     def try_read_lock
       if (held = @HeldCount.value) > 0
+        raise ResourceLimitError.new('Too many reader holds on this thread') if (held & READ_LOCK_MASK) == READ_LOCK_MASK
+
         if held & READ_LOCK_MASK == 0
           # If we hold a write lock, but not a read lock...
           @Counter.update { |c| c + 1 }

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

@@ -10,7 +10,6 @@ module Concurrent
     extend Concurrent::Synchronization::SafeInitialization
     include AtomicDirectUpdate
     include AtomicNumericCompareAndSetWrapper
-    alias_method :compare_and_swap, :compare_and_set
 
     # @!macro atomic_reference_method_initialize
     def initialize(value = nil)
@@ -42,7 +41,7 @@ module Concurrent
     alias_method :swap, :get_and_set
 
     # @!macro atomic_reference_method_compare_and_set
-    def _compare_and_set(old_value, new_value)
+    private def _compare_and_set(old_value, new_value)
       synchronize do
         if @value.equal? old_value
           @value = new_value

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

@@ -9,12 +9,18 @@ module Concurrent
     # @!macro atomic_reference_method_compare_and_set
     def compare_and_set(old_value, new_value)
       if old_value.kind_of? Numeric
+        # NaN is never == to itself; match it explicitly so #update can terminate.
+        expected_nan = old_value.respond_to?(:nan?) && old_value.nan?
         while true
           old = get
 
           return false unless old.kind_of? Numeric
 
-          return false unless old == old_value
+          if expected_nan
+            return false unless old.respond_to?(:nan?) && old.nan?
+          else
+            return false unless old == old_value
+          end
 
           result = _compare_and_set(old, new_value)
           return result if result
@@ -24,5 +30,7 @@ module Concurrent
       end
     end
 
+    alias_method :compare_and_swap, :compare_and_set
+
   end
 end

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/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 explicitly 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/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/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

@@ -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/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.5'
+  VERSION = '1.3.7'
 end

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.3.5
+  version: 1.3.7
 platform: ruby
 authors:
 - Jerry D'Antonio
 - Petr Chalupa
 - The Ruby Concurrency Team
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-01-15 00:00:00.000000000 Z
+date: 2026-06-16 00:00:00.000000000 Z
 dependencies: []
 description: |
   Modern concurrency tools including agents, futures, promises, thread pools, actors, supervisors, and more.
@@ -19,9 +18,9 @@ email: concurrent-ruby@googlegroups.com
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.md
-- LICENSE.txt
 - CHANGELOG.md
+- LICENSE.txt
+- README.md
 files:
 - CHANGELOG.md
 - Gemfile
@@ -82,6 +81,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
@@ -166,7 +167,6 @@ licenses:
 metadata:
   source_code_uri: https://github.com/ruby-concurrency/concurrent-ruby
   changelog_uri: https://github.com/ruby-concurrency/concurrent-ruby/blob/master/CHANGELOG.md
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib/concurrent-ruby
@@ -181,8 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
-signing_key: 
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Modern concurrency tools for Ruby. Inspired by Erlang, Clojure, Scala, Haskell,
   F#, C#, Java, and classic concurrency patterns.