concurrent-ruby 1.1.10 → 1.3.7

data/lib/concurrent-ruby/concurrent/utility/processor_counter.rb

@@ -3,6 +3,7 @@ require 'rbconfig'
 require 'concurrent/delay'
 
 module Concurrent
+  # @!visibility private
   module Utility
 
     # @!visibility private
@@ -10,70 +11,41 @@ module Concurrent
       def initialize
         @processor_count          = Delay.new { compute_processor_count }
         @physical_processor_count = Delay.new { compute_physical_processor_count }
+        @cpu_quota                = Delay.new { compute_cpu_quota }
+        @cpu_shares               = Delay.new { compute_cpu_shares }
       end
 
-      # Number of processors seen by the OS and used for process scheduling. For
-      # performance reasons the calculated value will be memoized on the first
-      # call.
-      #
-      # When running under JRuby the Java runtime call
-      # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
-      # to the Java documentation this "value may change during a particular
-      # invocation of the virtual machine... [applications] should therefore
-      # occasionally poll this property." Subsequently the result will NOT be
-      # memoized under JRuby.
-      #
-      # Ruby's Etc.nprocessors will be used if available (MRI 2.2+).
-      #
-      # On Windows the Win32 API will be queried for the
-      # `NumberOfLogicalProcessors from Win32_Processor`. This will return the
-      # total number "logical processors for the current instance of the
-      # processor", which taked into account hyperthreading.
-      #
-      # * AIX: /usr/sbin/pmcycles (AIX 5+), /usr/sbin/lsdev
-      # * Alpha: /usr/bin/nproc (/proc/cpuinfo exists but cannot be used)
-      # * BSD: /sbin/sysctl
-      # * Cygwin: /proc/cpuinfo
-      # * Darwin: /usr/bin/hwprefs, /usr/sbin/sysctl
-      # * HP-UX: /usr/sbin/ioscan
-      # * IRIX: /usr/sbin/sysconf
-      # * Linux: /proc/cpuinfo
-      # * Minix 3+: /proc/cpuinfo
-      # * Solaris: /usr/sbin/psrinfo
-      # * Tru64 UNIX: /usr/sbin/psrinfo
-      # * UnixWare: /usr/sbin/psrinfo
-      #
-      # @return [Integer] number of processors seen by the OS or Java runtime
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
       def processor_count
         @processor_count.value
       end
 
-      # Number of physical processor cores on the current system. For performance
-      # reasons the calculated value will be memoized on the first call.
-      #
-      # On Windows the Win32 API will be queried for the `NumberOfCores from
-      # Win32_Processor`. This will return the total number "of cores for the
-      # current instance of the processor." On Unix-like operating systems either
-      # the `hwprefs` or `sysctl` utility will be called in a subshell and the
-      # returned value will be used. In the rare case where none of these methods
-      # work or an exception is raised the function will simply return 1.
-      #
-      # @return [Integer] number physical processor cores on the current system
-      #
-      # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
-      #
-      # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
-      # @see http://www.unix.com/man-page/osx/1/HWPREFS/
-      # @see http://linux.die.net/man/8/sysctl
       def physical_processor_count
         @physical_processor_count.value
       end
 
+      def available_processor_count
+        cpu_count = processor_count.to_f
+        quota = cpu_quota
+
+        return cpu_count if quota.nil?
+
+        # cgroup cpus quotas have no limits, so they can be set to higher than the
+        # real count of cores.
+        if quota > cpu_count
+          cpu_count
+        else
+          quota
+        end
+      end
+
+      def cpu_quota
+        @cpu_quota.value
+      end
+
+      def cpu_shares
+        @cpu_shares.value
+      end
+
       private
 
       def compute_processor_count
@@ -101,10 +73,20 @@ module Concurrent
                 end
                 cores.count
               when /mswin|mingw/
-                require 'win32ole'
-                result_set = WIN32OLE.connect("winmgmts://").ExecQuery(
-                  "select NumberOfCores from Win32_Processor")
-                result_set.to_enum.collect(&:NumberOfCores).reduce(:+)
+                # Get-CimInstance introduced in PowerShell 3 or earlier: https://learn.microsoft.com/en-us/previous-versions/powershell/module/cimcmdlets/get-ciminstance?view=powershell-3.0
+                result = run('powershell -command "Get-CimInstance -ClassName Win32_Processor -Property NumberOfCores | Select-Object -Property NumberOfCores"')
+                if !result || $?.exitstatus != 0
+                  # fallback to deprecated wmic for older systems
+                  result = run("wmic cpu get NumberOfCores")
+                end
+                if !result || $?.exitstatus != 0
+                  # Bail out if both commands returned something unexpected
+                  processor_count
+                else
+                  # powershell: "\nNumberOfCores\n-------------\n            4\n\n\n"
+                  # wmic:       "NumberOfCores  \n\n4              \n\n\n\n"
+                  result.scan(/\d+/).map(&:to_i).reduce(:+)
+                end
               else
                 processor_count
               end
@@ -113,6 +95,45 @@ module Concurrent
       rescue
         return 1
       end
+
+      def run(command)
+        IO.popen(command, &:read)
+      rescue Errno::ENOENT
+      end
+
+      def compute_cpu_quota
+        if RbConfig::CONFIG["target_os"].include?("linux")
+          if File.exist?("/sys/fs/cgroup/cpu.max")
+            # cgroups v2: https://docs.kernel.org/admin-guide/cgroup-v2.html#cpu-interface-files
+            cpu_max = File.read("/sys/fs/cgroup/cpu.max")
+            return nil if cpu_max.start_with?("max ") # no limit
+            max, period = cpu_max.split.map(&:to_f)
+            max / period
+          elsif File.exist?("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_quota_us")
+            # cgroups v1: https://kernel.googlesource.com/pub/scm/linux/kernel/git/glommer/memcg/+/cpu_stat/Documentation/cgroups/cpu.txt
+            max = File.read("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_quota_us").to_i
+            # If the cpu.cfs_quota_us is -1, cgroup does not adhere to any CPU time restrictions
+            # https://docs.kernel.org/scheduler/sched-bwc.html#management
+            return nil if max <= 0
+            period = File.read("/sys/fs/cgroup/cpu,cpuacct/cpu.cfs_period_us").to_f
+            max / period
+          end
+        end
+      end
+
+      def compute_cpu_shares
+        if RbConfig::CONFIG["target_os"].include?("linux")
+          if File.exist?("/sys/fs/cgroup/cpu.weight")
+            # cgroups v2: https://docs.kernel.org/admin-guide/cgroup-v2.html#cpu-interface-files
+            # Ref: https://github.com/kubernetes/enhancements/tree/master/keps/sig-node/2254-cgroup-v2#phase-1-convert-from-cgroups-v1-settings-to-v2
+            weight = File.read("/sys/fs/cgroup/cpu.weight").to_f
+            ((((weight - 1) * 262142) / 9999) + 2) / 1024
+          elsif File.exist?("/sys/fs/cgroup/cpu/cpu.shares")
+            # cgroups v1: https://kernel.googlesource.com/pub/scm/linux/kernel/git/glommer/memcg/+/cpu_stat/Documentation/cgroups/cpu.txt
+            File.read("/sys/fs/cgroup/cpu/cpu.shares").to_f / 1024
+          end
+        end
+      end
     end
   end
 
@@ -120,11 +141,80 @@ module Concurrent
   @processor_counter = Utility::ProcessorCounter.new
   singleton_class.send :attr_reader, :processor_counter
 
+  # Number of processors seen by the OS and used for process scheduling. For
+  # performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # When running under JRuby the Java runtime call
+  # `java.lang.Runtime.getRuntime.availableProcessors` will be used. According
+  # to the Java documentation this "value may change during a particular
+  # invocation of the virtual machine... [applications] should therefore
+  # occasionally poll this property." We still memoize this value once under
+  # JRuby.
+  #
+  # Otherwise Ruby's Etc.nprocessors will be used.
+  #
+  # @return [Integer] number of processors seen by the OS or Java runtime
+  #
+  # @see http://docs.oracle.com/javase/6/docs/api/java/lang/Runtime.html#availableProcessors()
   def self.processor_count
     processor_counter.processor_count
   end
 
+  # Number of physical processor cores on the current system. For performance
+  # reasons the calculated value will be memoized on the first call.
+  #
+  # On Windows the Win32 API will be queried for the `NumberOfCores from
+  # Win32_Processor`. This will return the total number "of cores for the
+  # current instance of the processor." On Unix-like operating systems either
+  # the `hwprefs` or `sysctl` utility will be called in a subshell and the
+  # returned value will be used. In the rare case where none of these methods
+  # work or an exception is raised the function will simply return 1.
+  #
+  # @return [Integer] number physical processor cores on the current system
+  #
+  # @see https://github.com/grosser/parallel/blob/4fc8b89d08c7091fe0419ca8fba1ec3ce5a8d185/lib/parallel.rb
+  #
+  # @see http://msdn.microsoft.com/en-us/library/aa394373(v=vs.85).aspx
+  # @see http://www.unix.com/man-page/osx/1/HWPREFS/
+  # @see http://linux.die.net/man/8/sysctl
   def self.physical_processor_count
     processor_counter.physical_processor_count
   end
+
+  # Number of processors cores available for process scheduling.
+  # This method takes in account the CPU quota if the process is inside a cgroup with a
+  # dedicated CPU quota (typically Docker).
+  # Otherwise it returns the same value as #processor_count but as a Float.
+  #
+  # For performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # @return [Float] number of available processors
+  def self.available_processor_count
+    processor_counter.available_processor_count
+  end
+
+  # The maximum number of processors cores available for process scheduling.
+  # Returns `nil` if there is no enforced limit, or a `Float` if the
+  # process is inside a cgroup with a dedicated CPU quota (typically Docker).
+  #
+  # Note that nothing prevents setting a CPU quota higher than the actual number of
+  # cores on the system.
+  #
+  # For performance reasons the calculated value will be memoized on the first
+  # call.
+  #
+  # @return [nil, Float] Maximum number of available processors as set by a cgroup CPU quota, or nil if none set
+  def self.cpu_quota
+    processor_counter.cpu_quota
+  end
+
+  # The CPU shares requested by the process. For performance reasons the calculated
+  # value will be memoized on the first call.
+  #
+  # @return [Float, nil] CPU shares requested by the process, or nil if not set
+  def self.cpu_shares
+    processor_counter.cpu_shares
+  end
 end

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

@@ -1,3 +1,3 @@
 module Concurrent
-  VERSION = '1.1.10'
+  VERSION = '1.3.7'
 end

metadata

@@ -1,16 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 1.1.10
+  version: 1.3.7
 platform: ruby
 authors:
 - Jerry D'Antonio
 - Petr Chalupa
 - The Ruby Concurrency Team
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-22 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
@@ -49,7 +48,6 @@ files:
 - lib/concurrent-ruby/concurrent/array.rb
 - lib/concurrent-ruby/concurrent/async.rb
 - lib/concurrent-ruby/concurrent/atom.rb
-- lib/concurrent-ruby/concurrent/atomic/abstract_thread_local_var.rb
 - lib/concurrent-ruby/concurrent/atomic/atomic_boolean.rb
 - lib/concurrent-ruby/concurrent/atomic/atomic_fixnum.rb
 - lib/concurrent-ruby/concurrent/atomic/atomic_markable_reference.rb
@@ -57,17 +55,19 @@ files:
 - lib/concurrent-ruby/concurrent/atomic/count_down_latch.rb
 - lib/concurrent-ruby/concurrent/atomic/cyclic_barrier.rb
 - lib/concurrent-ruby/concurrent/atomic/event.rb
+- lib/concurrent-ruby/concurrent/atomic/fiber_local_var.rb
 - lib/concurrent-ruby/concurrent/atomic/java_count_down_latch.rb
-- lib/concurrent-ruby/concurrent/atomic/java_thread_local_var.rb
+- lib/concurrent-ruby/concurrent/atomic/locals.rb
+- lib/concurrent-ruby/concurrent/atomic/lock_local_var.rb
 - lib/concurrent-ruby/concurrent/atomic/mutex_atomic_boolean.rb
 - lib/concurrent-ruby/concurrent/atomic/mutex_atomic_fixnum.rb
 - lib/concurrent-ruby/concurrent/atomic/mutex_count_down_latch.rb
 - lib/concurrent-ruby/concurrent/atomic/mutex_semaphore.rb
 - lib/concurrent-ruby/concurrent/atomic/read_write_lock.rb
 - lib/concurrent-ruby/concurrent/atomic/reentrant_read_write_lock.rb
-- lib/concurrent-ruby/concurrent/atomic/ruby_thread_local_var.rb
 - lib/concurrent-ruby/concurrent/atomic/semaphore.rb
 - lib/concurrent-ruby/concurrent/atomic/thread_local_var.rb
+- lib/concurrent-ruby/concurrent/atomic_reference/atomic_direct_update.rb
 - lib/concurrent-ruby/concurrent/atomic_reference/mutex_atomic.rb
 - lib/concurrent-ruby/concurrent/atomic_reference/numeric_cas_wrapper.rb
 - lib/concurrent-ruby/concurrent/atomics.rb
@@ -75,13 +75,14 @@ files:
 - lib/concurrent-ruby/concurrent/collection/copy_on_write_observer_set.rb
 - lib/concurrent-ruby/concurrent/collection/java_non_concurrent_priority_queue.rb
 - lib/concurrent-ruby/concurrent/collection/lock_free_stack.rb
-- lib/concurrent-ruby/concurrent/collection/map/atomic_reference_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/mri_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/non_concurrent_map_backend.rb
 - lib/concurrent-ruby/concurrent/collection/map/synchronized_map_backend.rb
 - 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
@@ -135,21 +136,17 @@ files:
 - lib/concurrent-ruby/concurrent/synchronization/abstract_object.rb
 - lib/concurrent-ruby/concurrent/synchronization/abstract_struct.rb
 - lib/concurrent-ruby/concurrent/synchronization/condition.rb
+- lib/concurrent-ruby/concurrent/synchronization/full_memory_barrier.rb
 - lib/concurrent-ruby/concurrent/synchronization/jruby_lockable_object.rb
-- lib/concurrent-ruby/concurrent/synchronization/jruby_object.rb
 - lib/concurrent-ruby/concurrent/synchronization/lock.rb
 - lib/concurrent-ruby/concurrent/synchronization/lockable_object.rb
-- lib/concurrent-ruby/concurrent/synchronization/mri_object.rb
 - lib/concurrent-ruby/concurrent/synchronization/mutex_lockable_object.rb
 - lib/concurrent-ruby/concurrent/synchronization/object.rb
-- lib/concurrent-ruby/concurrent/synchronization/rbx_lockable_object.rb
-- lib/concurrent-ruby/concurrent/synchronization/rbx_object.rb
-- lib/concurrent-ruby/concurrent/synchronization/truffleruby_object.rb
+- lib/concurrent-ruby/concurrent/synchronization/safe_initialization.rb
 - lib/concurrent-ruby/concurrent/synchronization/volatile.rb
 - lib/concurrent-ruby/concurrent/thread_safe/synchronized_delegator.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/adder.rb
-- lib/concurrent-ruby/concurrent/thread_safe/util/cheap_lockable.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/data_structures.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/power_of_two_tuple.rb
 - lib/concurrent-ruby/concurrent/thread_safe/util/striped64.rb
@@ -170,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
@@ -178,15 +174,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.2'
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.4
-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.

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

@@ -1,66 +0,0 @@
-require 'concurrent/constants'
-
-module Concurrent
-
-  # @!macro thread_local_var
-  # @!macro internal_implementation_note
-  # @!visibility private
-  class AbstractThreadLocalVar
-
-    # @!macro thread_local_var_method_initialize
-    def initialize(default = nil, &default_block)
-      if default && block_given?
-        raise ArgumentError, "Cannot use both value and block as default value"
-      end
-
-      if block_given?
-        @default_block = default_block
-        @default = nil
-      else
-        @default_block = nil
-        @default = default
-      end
-
-      allocate_storage
-    end
-
-    # @!macro thread_local_var_method_get
-    def value
-      raise NotImplementedError
-    end
-
-    # @!macro thread_local_var_method_set
-    def value=(value)
-      raise NotImplementedError
-    end
-
-    # @!macro thread_local_var_method_bind
-    def bind(value, &block)
-      if block_given?
-        old_value = self.value
-        begin
-          self.value = value
-          yield
-        ensure
-          self.value = old_value
-        end
-      end
-    end
-
-    protected
-
-    # @!visibility private
-    def allocate_storage
-      raise NotImplementedError
-    end
-
-    # @!visibility private
-    def default
-      if @default_block
-        self.value = @default_block.call
-      else
-        @default
-      end
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-require 'concurrent/atomic/abstract_thread_local_var'
-
-if Concurrent.on_jruby?
-
-  module Concurrent
-
-    # @!visibility private
-    # @!macro internal_implementation_note
-    class JavaThreadLocalVar < AbstractThreadLocalVar
-
-      # @!macro thread_local_var_method_get
-      def value
-        value = @var.get
-
-        if value.nil?
-          default
-        elsif value == NULL
-          nil
-        else
-          value
-        end
-      end
-
-      # @!macro thread_local_var_method_set
-      def value=(value)
-        @var.set(value)
-      end
-
-      protected
-
-      # @!visibility private
-      def allocate_storage
-        @var = java.lang.ThreadLocal.new
-      end
-    end
-  end
-end

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

@@ -1,181 +0,0 @@
-require 'thread'
-require 'concurrent/atomic/abstract_thread_local_var'
-
-module Concurrent
-
-  # @!visibility private
-  # @!macro internal_implementation_note
-  class RubyThreadLocalVar < AbstractThreadLocalVar
-
-    # Each thread has a (lazily initialized) array of thread-local variable values
-    # Each time a new thread-local var is created, we allocate an "index" for it
-    # For example, if the allocated index is 1, that means slot #1 in EVERY
-    #   thread's thread-local array will be used for the value of that TLV
-    #
-    # The good thing about using a per-THREAD structure to hold values, rather
-    #   than a per-TLV structure, is that no synchronization is needed when
-    #    reading and writing those values (since the structure is only ever
-    #    accessed by a single thread)
-    #
-    # Of course, when a TLV is GC'd, 1) we need to recover its index for use
-    #   by other new TLVs (otherwise the thread-local arrays could get bigger
-    #   and bigger with time), and 2) we need to null out all the references
-    #   held in the now-unused slots (both to avoid blocking GC of those objects,
-    #   and also to prevent "stale" values from being passed on to a new TLV
-    #   when the index is reused)
-    # Because we need to null out freed slots, we need to keep references to
-    #   ALL the thread-local arrays -- ARRAYS is for that
-    # But when a Thread is GC'd, we need to drop the reference to its thread-local
-    #   array, so we don't leak memory
-
-    FREE                = []
-    LOCK                = Mutex.new
-    THREAD_LOCAL_ARRAYS = {} # used as a hash set
-
-    # synchronize when not on MRI
-    # on MRI using lock in finalizer leads to "can't be called from trap context" error
-    # so the code is carefully written to be tread-safe on MRI relying on GIL
-
-    if Concurrent.on_cruby?
-      # @!visibility private
-      def self.semi_sync(&block)
-        block.call
-      end
-    else
-      # @!visibility private
-      def self.semi_sync(&block)
-        LOCK.synchronize(&block)
-      end
-    end
-
-    private_constant :FREE, :LOCK, :THREAD_LOCAL_ARRAYS
-
-    # @!macro thread_local_var_method_get
-    def value
-      if (array = get_threadlocal_array)
-        value = array[@index]
-        if value.nil?
-          default
-        elsif value.equal?(NULL)
-          nil
-        else
-          value
-        end
-      else
-        default
-      end
-    end
-
-    # @!macro thread_local_var_method_set
-    def value=(value)
-      me = Thread.current
-      # We could keep the thread-local arrays in a hash, keyed by Thread
-      # But why? That would require locking
-      # Using Ruby's built-in thread-local storage is faster
-      unless (array = get_threadlocal_array(me))
-        array = set_threadlocal_array([], me)
-        self.class.semi_sync { THREAD_LOCAL_ARRAYS[array.object_id] = array }
-        ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array.object_id))
-      end
-      array[@index] = (value.nil? ? NULL : value)
-      value
-    end
-
-    protected
-
-    # @!visibility private
-    def allocate_storage
-      @index = FREE.pop || next_index
-
-      ObjectSpace.define_finalizer(self, self.class.thread_local_finalizer(@index))
-    end
-
-    # @!visibility private
-    def self.thread_local_finalizer(index)
-      proc do
-        semi_sync do
-          # The cost of GC'ing a TLV is linear in the number of threads using TLVs
-          # But that is natural! More threads means more storage is used per TLV
-          # So naturally more CPU time is required to free more storage
-          #
-          # DO NOT use each_value which might conflict with new pair assignment
-          # into the hash in #value= method
-          THREAD_LOCAL_ARRAYS.values.each { |array| array[index] = nil }
-          # free index has to be published after the arrays are cleared
-          FREE.push(index)
-        end
-      end
-    end
-
-    # @!visibility private
-    def self.thread_finalizer(id)
-      proc do
-        semi_sync do
-          # The thread which used this thread-local array is now gone
-          # So don't hold onto a reference to the array (thus blocking GC)
-          THREAD_LOCAL_ARRAYS.delete(id)
-        end
-      end
-    end
-
-    private
-
-    # noinspection RubyClassVariableUsageInspection
-    @@next = 0
-    # noinspection RubyClassVariableUsageInspection
-    def next_index
-      LOCK.synchronize do
-        result = @@next
-        @@next += 1
-        result
-      end
-    end
-
-    if Thread.instance_methods.include?(:thread_variable_get)
-
-      def get_threadlocal_array(thread = Thread.current)
-        thread.thread_variable_get(:__threadlocal_array__)
-      end
-
-      def set_threadlocal_array(array, thread = Thread.current)
-        thread.thread_variable_set(:__threadlocal_array__, array)
-      end
-
-    else
-
-      def get_threadlocal_array(thread = Thread.current)
-        thread[:__threadlocal_array__]
-      end
-
-      def set_threadlocal_array(array, thread = Thread.current)
-        thread[:__threadlocal_array__] = array
-      end
-    end
-
-    # This exists only for use in testing
-    # @!visibility private
-    def value_for(thread)
-      if (array = get_threadlocal_array(thread))
-        value = array[@index]
-        if value.nil?
-          get_default
-        elsif value.equal?(NULL)
-          nil
-        else
-          value
-        end
-      else
-        get_default
-      end
-    end
-
-    # @!visibility private
-    def get_default
-      if @default_block
-        raise "Cannot use default_for with default block"
-      else
-        @default
-      end
-    end
-  end
-end