MRI 1.9.3 & Rbx updates to TLV

Author: jdantonio

lib/concurrent/atomic/thread_local_var.rb

@@ -133,7 +133,7 @@ def initialize(default = nil)
 
     # @!macro thread_local_var_method_get
     def value
-      if array = Thread.current.thread_variable_get(:__threadlocal_array__)
+      if array = get_threadlocal_array
         value = array[@index]
         if value.nil?
           @default
@@ -153,8 +153,8 @@ def value=(value)
       # 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 = me.thread_variable_get(:__threadlocal_array__)
-        array = me.thread_variable_set(:__threadlocal_array__, [])
+      unless array = get_threadlocal_array(me)
+        array = set_threadlocal_array([], me)
         LOCK.synchronize { ARRAYS[array.object_id] = array }
         ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
       end
@@ -217,10 +217,31 @@ def self.thread_finalizer(array)
 
     private
 
+    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 = thread.thread_variable_get(:__threadlocal_array__)
+      if array = get_threadlocal_array(thread)
         value = array[@index]
         if value.nil?
           @default

spec/concurrent/atomic/reentrant_read_write_lock_spec.rb

@@ -1,4 +1,4 @@
-unless Concurrent.on_jruby? || Concurrent.ruby_version(:<, 2)
+unless Concurrent.on_jruby?
 
   # NOTE: These tests depend heavily on the private/undocumented
   # `ThreadLocalVar#value_for` method. This method does not, and cannot work

spec/concurrent/atomic/thread_local_var_spec.rb

@@ -1,108 +1,105 @@
-unless Concurrent.ruby_version(:<, 2)
+require 'rbconfig'
 
-  require 'rbconfig'
+module Concurrent
 
-  module Concurrent
+  require 'concurrent/atomic/thread_local_var'
 
-    require 'concurrent/atomic/thread_local_var'
+  describe ThreadLocalVar do
 
-    describe ThreadLocalVar do
+    subject { ThreadLocalVar.new }
 
-      subject { ThreadLocalVar.new }
+    context '#initialize' do
 
-      context '#initialize' do
+      it 'can set an initial value' do
+        v = ThreadLocalVar.new(14)
+        expect(v.value).to eq 14
+      end
 
-        it 'can set an initial value' do
-          v = ThreadLocalVar.new(14)
-          expect(v.value).to eq 14
-        end
+      it 'sets nil as a default initial value' do
+        v = ThreadLocalVar.new
+        expect(v.value).to be_nil
+      end
 
-        it 'sets nil as a default initial value' do
-          v = ThreadLocalVar.new
-          expect(v.value).to be_nil
-        end
+      it 'sets the same initial value for all threads' do
+        v  = ThreadLocalVar.new(14)
+        t1 = Thread.new { v.value }
+        t2 = Thread.new { v.value }
+        expect(t1.value).to eq 14
+        expect(t2.value).to eq 14
+      end
 
-        it 'sets the same initial value for all threads' do
-          v  = ThreadLocalVar.new(14)
-          t1 = Thread.new { v.value }
-          t2 = Thread.new { v.value }
-          expect(t1.value).to eq 14
-          expect(t2.value).to eq 14
+      if Concurrent.on_jruby?
+        it 'extends JavaThreadLocalVar' do
+          expect(subject.class.ancestors).to include(Concurrent::JavaThreadLocalVar)
         end
-
-        if Concurrent.on_jruby?
-          it 'extends JavaThreadLocalVar' do
-            expect(subject.class.ancestors).to include(Concurrent::JavaThreadLocalVar)
-          end
-        else
-          it 'extends RubyThreadLocalVar' do
-            expect(subject.class.ancestors).to include(Concurrent::RubyThreadLocalVar)
-          end
+      else
+        it 'extends RubyThreadLocalVar' do
+          expect(subject.class.ancestors).to include(Concurrent::RubyThreadLocalVar)
         end
       end
+    end
 
-      context '#value' do
+    context '#value' do
 
-        it 'returns the current value' do
-          v = ThreadLocalVar.new(14)
-          expect(v.value).to eq 14
-        end
+      it 'returns the current value' do
+        v = ThreadLocalVar.new(14)
+        expect(v.value).to eq 14
+      end
 
-        it 'returns the value after modification' do
-          v = ThreadLocalVar.new(14)
-          v.value = 2
-          expect(v.value).to eq 2
-        end
+      it 'returns the value after modification' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
+        expect(v.value).to eq 2
+      end
+    end
+
+    context '#value=' do
+
+      it 'sets a new value' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
+        expect(v.value).to eq 2
       end
 
-      context '#value=' do
+      it 'returns the new value' do
+        v = ThreadLocalVar.new(14)
+        expect(v.value = 2).to eq 2
+      end
 
-        it 'sets a new value' do
-          v = ThreadLocalVar.new(14)
-          v.value = 2
-          expect(v.value).to eq 2
-        end
+      it 'does not modify the initial value for other threads' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
+        t = Thread.new { v.value }
+        expect(t.value).to eq 14
+      end
 
-        it 'returns the new value' do
-          v = ThreadLocalVar.new(14)
-          expect(v.value = 2).to eq 2
-        end
+      it 'does not modify the value for other threads' do
+        v = ThreadLocalVar.new(14)
+        v.value = 2
 
-        it 'does not modify the initial value for other threads' do
-          v = ThreadLocalVar.new(14)
-          v.value = 2
-          t = Thread.new { v.value }
-          expect(t.value).to eq 14
+        b1 = CountDownLatch.new(2)
+        b2 = CountDownLatch.new(2)
+
+        t1 = Thread.new do
+          b1.count_down
+          b1.wait
+          v.value = 1
+          b2.count_down
+          b2.wait
+          v.value
         end
 
-        it 'does not modify the value for other threads' do
-          v = ThreadLocalVar.new(14)
+        t2 = Thread.new do
+          b1.count_down
+          b1.wait
           v.value = 2
-
-          b1 = CountDownLatch.new(2)
-          b2 = CountDownLatch.new(2)
-
-          t1 = Thread.new do
-            b1.count_down
-            b1.wait
-            v.value = 1
-            b2.count_down
-            b2.wait
-            v.value
-          end
-
-          t2 = Thread.new do
-            b1.count_down
-            b1.wait
-            v.value = 2
-            b2.count_down
-            b2.wait
-            v.value
-          end
-
-          expect(t1.value).to eq 1
-          expect(t2.value).to eq 2
+          b2.count_down
+          b2.wait
+          v.value
         end
+
+        expect(t1.value).to eq 1
+        expect(t2.value).to eq 2
       end
     end
   end