concurrent-ruby 1.2.2 → 1.3.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1cad803df2c0fe187f3208dce2972feaa94daefcbd3749770abe3abfc0642fe9
-  data.tar.gz: 216b0196496fde70f53cc82b83cd593ec5267a53dcac9a312f254ae627f7761e
+  metadata.gz: 0d094624e5f9f2dffc45b80892987f339d8b8c09ff2f01cf923e3825dd6409f7
+  data.tar.gz: 02adb496e81a3adb7e3c6042f72ec421677851033d57eb77b0e1b3641ef70684
 SHA512:
-  metadata.gz: 605762fd9c26a5a783dcb834f9db5d818ba2b52431b382a7abd33aaddfcc0df8c5005abf0e1a7ebacf3aced9ebb61ee7080fd59050805422f4fc5593925ae935
-  data.tar.gz: ae916f03459f583497ab268aa82cc79d24dcddb2c51a86abf86313ad77faf975d10d22048ca03179c6583832fc0e25f3f3c1618de0668f9a2774486d7e15e41c
+  metadata.gz: 43a4af037c64d4ee8e128963db7a3f40213a45898289bb9143aa222e5664982b8c0fa08d2dae8e629fa7766be6a528b74b5ba17fbbb5cb741a9b5c08020eea15
+  data.tar.gz: 0203e085d78340af99c8d8cbf2f0aa8793db6bfdbe4c25cd2ff622816581004c2871851c621d23bcfd653be30fd3aca682e98a3117b64e5735d23bb2a3bfb4c0

data/CHANGELOG.md

@@ -1,5 +1,59 @@
 ## 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:
+
+* (#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.
+* (#1058) Add `Concurrent.cpu_shares` that is cgroups aware.
+
+## Release v1.3.3 (9 June 2024)
+
+* (#1053) Improve the speed of `Concurrent.physical_processor_count` on Windows.
+
+## Release v1.3.2, edge v0.7.1 (7 June 2024)
+
+concurrent-ruby:
+
+* (#1051) Remove dependency on `win32ole`.
+
+concurrent-ruby-edge:
+
+* (#1052) Fix dependency on `concurrent-ruby` to allow the latest release.
+
+## Release v1.3.1 (29 May 2024)
+
+* Release 1.3.0 was broken when pushed to RubyGems. 1.3.1 is a packaging fix.
+
+## Release v1.3.0 (28 May 2024)
+
+* (#1042) Align Java Executor Service behavior for `shuttingdown?`, `shutdown?`
+* (#1038) Add `Concurrent.available_processor_count` that is cgroups aware.
+
+## Release v1.2.3 (16 Jan 2024)
+
+* See [the GitHub release](https://github.com/ruby-concurrency/concurrent-ruby/releases/tag/v1.2.3) for details.
+
 ## Release v1.2.2 (24 Feb 2023)
 
 * (#993) Fix arguments passed to `Concurrent::Map`'s `default_proc`.
@@ -264,7 +318,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`
@@ -439,7 +493,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/Gemfile

@@ -1,18 +1,18 @@
 source 'https://rubygems.org'
 
-require File.join(File.dirname(__FILE__), 'lib/concurrent-ruby/concurrent/version')
-require File.join(File.dirname(__FILE__ ), 'lib/concurrent-ruby-edge/concurrent/edge/version')
+version = File.read("#{__dir__}/lib/concurrent-ruby/concurrent/version.rb")[/'(.+)'/, 1] or raise
+edge_version = File.read("#{__dir__}/lib/concurrent-ruby-edge/concurrent/edge/version.rb")[/'(.+)'/, 1] or raise
 
 no_path = ENV['NO_PATH']
 options = no_path ? {} : { path: '.' }
 
-gem 'concurrent-ruby', Concurrent::VERSION, options
-gem 'concurrent-ruby-edge', Concurrent::EDGE_VERSION, options
-gem 'concurrent-ruby-ext', Concurrent::VERSION, options.merge(platform: :mri)
+gem 'concurrent-ruby', version, options
+gem 'concurrent-ruby-edge', edge_version, options
+gem 'concurrent-ruby-ext', version, options.merge(platform: :mri)
 
 group :development do
   gem 'rake', '~> 13.0'
-  gem 'rake-compiler', '~> 1.0', '>= 1.0.7'
+  gem 'rake-compiler', '~> 1.0', '>= 1.0.7', '!= 1.2.4'
   gem 'rake-compiler-dock', '~> 1.0'
   gem 'pry', '~> 0.11', platforms: :mri
 end

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
 
@@ -375,7 +376,10 @@ best practice is to depend on `concurrent-ruby` and let users to decide if they
 * [Benoit Daloze](https://github.com/eregon)
 * [Matthew Draper](https://github.com/matthewd)
 * [Rafael França](https://github.com/rafaelfranca)
+* [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

@@ -1,6 +1,5 @@
-require_relative 'lib/concurrent-ruby/concurrent/version'
-require_relative 'lib/concurrent-ruby-edge/concurrent/edge/version'
-require_relative 'lib/concurrent-ruby/concurrent/utility/engine'
+version = File.read("#{__dir__}/lib/concurrent-ruby/concurrent/version.rb")[/'(.+)'/, 1] or raise
+edge_version = File.read("#{__dir__}/lib/concurrent-ruby-edge/concurrent/edge/version.rb")[/'(.+)'/, 1] or raise
 
 core_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby.gemspec')
 ext_gemspec  = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-ext.gemspec')
@@ -8,14 +7,16 @@ edge_gemspec = Gem::Specification.load File.join(__dir__, 'concurrent-ruby-edge.
 
 require 'rake/javaextensiontask'
 
-ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME'] && !Concurrent.on_jruby?
+ENV['JRUBY_HOME'] = ENV['CONCURRENT_JRUBY_HOME'] if ENV['CONCURRENT_JRUBY_HOME'] && RUBY_ENGINE != 'jruby'
 
 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
 
-unless Concurrent.on_jruby? || Concurrent.on_truffleruby?
+if RUBY_ENGINE == 'ruby'
   require 'rake/extensiontask'
 
   Rake::ExtensionTask.new('concurrent_ruby_ext', ext_gemspec) do |ext|
@@ -28,6 +29,10 @@ unless Concurrent.on_jruby? || Concurrent.on_truffleruby?
   end
 end
 
+def which?(executable)
+  !`which #{executable} 2>/dev/null`.empty?
+end
+
 require 'rake_compiler_dock'
 namespace :repackage do
   desc '* with Windows fat distributions'
@@ -42,12 +47,19 @@ namespace :repackage do
       Rake::Task['lib/concurrent-ruby/concurrent/concurrent_ruby.jar'].invoke
 
       # build all gem files
+      rack_compiler_dock_kwargs = {}
+      if which?('podman') and (!which?('docker') || `docker --version`.include?('podman'))
+        # podman and only podman available, so RakeCompilerDock will use podman, otherwise it uses docker
+        rack_compiler_dock_kwargs = {
+          options: ['--privileged'], # otherwise the directory in the image is empty
+          runas: false
+        }
+      end
       %w[x86-mingw32 x64-mingw32].each do |plat|
         RakeCompilerDock.sh(
           "bundle install --local && bundle exec rake native:#{plat} gem --trace",
           platform: plat,
-          options: ['--privileged'], # otherwise the directory in the image is empty
-          runas: false)
+          **rack_compiler_dock_kwargs)
       end
     end
   end
@@ -57,7 +69,7 @@ require 'rubygems'
 require 'rubygems/package_task'
 
 Gem::PackageTask.new(core_gemspec) {} if core_gemspec
-Gem::PackageTask.new(ext_gemspec) {} if ext_gemspec && !Concurrent.on_jruby?
+Gem::PackageTask.new(ext_gemspec) {} if ext_gemspec && RUBY_ENGINE != 'jruby'
 Gem::PackageTask.new(edge_gemspec) {} if edge_gemspec
 
 CLEAN.include(
@@ -85,9 +97,9 @@ begin
     task :installed do
       Bundler.with_original_env do
         Dir.chdir(__dir__) do
-          sh "gem install pkg/concurrent-ruby-#{Concurrent::VERSION}.gem"
-          sh "gem install pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if Concurrent.on_cruby?
-          sh "gem install pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem"
+          sh "gem install pkg/concurrent-ruby-#{version}.gem"
+          sh "gem install pkg/concurrent-ruby-ext-#{version}.gem" if RUBY_ENGINE == 'ruby'
+          sh "gem install pkg/concurrent-ruby-edge-#{edge_version}.gem"
           ENV['NO_PATH'] = 'true'
           sh 'bundle update'
           sh 'bundle exec rake spec:ci'
@@ -117,7 +129,7 @@ rescue LoadError => e
   puts 'RSpec is not installed, skipping test task definitions: ' + e.message
 end
 
-current_yard_version_name = Concurrent::VERSION
+current_yard_version_name = version
 
 begin
   require 'yard'
@@ -221,6 +233,8 @@ namespace :release do
   # Depends on environment of @pitr-ch
 
   task :checks do
+    raise '$CONCURRENT_JRUBY_HOME must be set' unless ENV['CONCURRENT_JRUBY_HOME']
+
     Dir.chdir(__dir__) do
       sh 'test -z "$(git status --porcelain)"' do |ok, res|
         unless ok
@@ -251,15 +265,19 @@ namespace :release do
 
   desc '* test actual installed gems instead of cloned repository on MRI and JRuby'
   task :test do
+    raise '$CONCURRENT_JRUBY_HOME must be set' unless ENV['CONCURRENT_JRUBY_HOME']
+
     Dir.chdir(__dir__) do
       puts "Testing with the installed gem"
 
       Bundler.with_original_env do
         sh 'ruby -v'
+        sh 'bundle install'
         sh 'bundle exec rake spec:installed'
 
-        env = { "PATH" => "#{ENV['CONCURRENT_JRUBY_HOME']}/bin:#{ENV['PATH']}" }
+        env = { "PATH" => "#{ENV.fetch('CONCURRENT_JRUBY_HOME')}/bin:#{ENV['PATH']}" }
         sh env, 'ruby -v'
+        sh env, 'bundle install'
         sh env, 'bundle exec rake spec:installed'
       end
 
@@ -271,8 +289,8 @@ namespace :release do
   task :publish => ['publish:ask', 'publish:tag', 'publish:rubygems', 'publish:post_steps']
 
   namespace :publish do
-    publish_base = true
-    publish_edge = false
+    publish_base = nil
+    publish_edge = nil
 
     task :ask do
       begin
@@ -280,8 +298,15 @@ namespace :release do
         input = STDIN.gets.strip.downcase
       end until %w(y n).include?(input)
       exit 1 if input == 'n'
+
+      begin
+        STDOUT.puts 'Do you want to publish `concurrent-ruby`? (y/n)'
+        input = STDIN.gets.strip.downcase
+      end until %w(y n).include?(input)
+      publish_base = input == 'y'
+
       begin
-        STDOUT.puts 'It will publish `concurrent-ruby`. Do you want to publish `concurrent-ruby-edge`? (y/n)'
+        STDOUT.puts 'Do you want to publish `concurrent-ruby-edge`? (y/n)'
         input = STDIN.gets.strip.downcase
       end until %w(y n).include?(input)
       publish_edge = input == 'y'
@@ -290,29 +315,28 @@ namespace :release do
     desc '** tag HEAD with current version and push to github'
     task :tag => :ask do
       Dir.chdir(__dir__) do
-        sh "git tag v#{Concurrent::VERSION}" if publish_base
-        sh "git push origin v#{Concurrent::VERSION}" if publish_base
-        sh "git tag edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
-        sh "git push origin edge-v#{Concurrent::EDGE_VERSION}" if publish_edge
+        sh "git tag v#{version}" if publish_base
+        sh "git push origin v#{version}" if publish_base
+        sh "git tag edge-v#{edge_version}" if publish_edge
+        sh "git push origin edge-v#{edge_version}" if publish_edge
       end
     end
 
     desc '** push all *.gem files to rubygems'
     task :rubygems => :ask do
       Dir.chdir(__dir__) do
-        sh "gem push pkg/concurrent-ruby-#{Concurrent::VERSION}.gem" if publish_base
-        sh "gem push pkg/concurrent-ruby-edge-#{Concurrent::EDGE_VERSION}.gem" if publish_edge
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}.gem" if publish_base
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x64-mingw32.gem" if publish_base
-        sh "gem push pkg/concurrent-ruby-ext-#{Concurrent::VERSION}-x86-mingw32.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-#{version}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-edge-#{edge_version}.gem" if publish_edge
+        sh "gem push pkg/concurrent-ruby-ext-#{version}.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{version}-x64-mingw32.gem" if publish_base
+        sh "gem push pkg/concurrent-ruby-ext-#{version}-x86-mingw32.gem" if publish_base
       end
     end
 
     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/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/array.rb

@@ -21,9 +21,9 @@ module Concurrent
   # @!macro internal_implementation_note
   ArrayImplementation = case
                         when Concurrent.on_cruby?
-                          # Array is thread-safe in practice because CRuby runs
-                          # threads one at a time and does not do context
-                          # switching during the execution of C functions.
+                          # Array is not fully thread-safe on CRuby, see
+                          # https://github.com/ruby-concurrency/concurrent-ruby/issues/929
+                          # So we will need to add synchronization here
                           ::Array
 
                         when Concurrent.on_jruby?

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