concurrent-ruby 1.3.6 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e27f11f8dd5047c9ca365ca8babf3241defab1d707be5055720d1b905e5aa188
-  data.tar.gz: 3c5c5e998d8bd76b3b1faf813b870e779d9546149bb6a88a229659dfd741dd13
+  metadata.gz: 0d094624e5f9f2dffc45b80892987f339d8b8c09ff2f01cf923e3825dd6409f7
+  data.tar.gz: 02adb496e81a3adb7e3c6042f72ec421677851033d57eb77b0e1b3641ef70684
 SHA512:
-  metadata.gz: c5cf562bf20ba3f20c5ed974a90b55d5f9f08e70fb4af2b722b296ebc1f2726daf431b7410199f19b310b22da260d85d6508c472ef59356903b51ab1123d4d1d
-  data.tar.gz: e187fd07e9e10852e408a6c371be9b734b1821fbc42b7c820440caafa5febef3786cf4fd473bd81f1e28c59e1cb4f177ebeec47ef913ed9445425003022c0a65
+  metadata.gz: 43a4af037c64d4ee8e128963db7a3f40213a45898289bb9143aa222e5664982b8c0fa08d2dae8e629fa7766be6a528b74b5ba17fbbb5cb741a9b5c08020eea15
+  data.tar.gz: 0203e085d78340af99c8d8cbf2f0aa8793db6bfdbe4c25cd2ff622816581004c2871851c621d23bcfd653be30fd3aca682e98a3117b64e5735d23bb2a3bfb4c0

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## 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:

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/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/version.rb

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '1.3.6'
+  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.6
+  version: 1.3.7
 platform: ruby
 authors:
 - Jerry D'Antonio
 - Petr Chalupa
 - The Ruby Concurrency Team
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-12-13 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
@@ -168,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
@@ -183,8 +181,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.27
-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.