Merge pull request #387 from ruby-concurrency/more-thread-local-var

Updates to ThreadLocalVar

Author: jdantonio

lib/concurrent/atomic/thread_local_var.rb

@@ -33,7 +33,65 @@ module Concurrent
   #
   #   @see https://docs.oracle.com/javase/7/docs/api/java/lang/ThreadLocal.html Java ThreadLocal
   #
-  class ThreadLocalVar
+  # @!visibility private
+  class AbstractThreadLocalVar
+
+    # @!visibility private
+    NIL_SENTINEL = Object.new
+    private_constant :NIL_SENTINEL
+
+    # @!macro [attach] thread_local_var_method_initialize
+    #
+    #   Creates a thread local variable.
+    #
+    #   @param [Object] default the default value when otherwise unset
+    def initialize(default = nil)
+      @default = default
+      allocate_storage
+    end
+
+    # @!macro [attach] thread_local_var_method_get
+    #
+    #   Returns the value in the current thread's copy of this thread-local variable.
+    #
+    #   @return [Object] the current value
+    def value
+      raise NotImplementedError
+    end
+
+    # @!macro [attach] thread_local_var_method_set
+    #
+    #   Sets the current thread's copy of this thread-local variable to the specified value.
+    #
+    #   @param [Object] value the value to set
+    #   @return [Object] the new value
+    def value=(value)
+      raise NotImplementedError
+    end
+
+    # @!macro [attach] thread_local_var_method_bind
+    #
+    #   Bind the given value to thread local storage during
+    #   execution of the given block.
+    #
+    #   @param [Object] value the value to bind
+    #   @yield the operation to be performed with the bound variable
+    #   @return [Object] the value
+    def bind(value, &block)
+      raise NotImplementedError
+    end
+
+    protected
+
+    # @!visibility private
+    def allocate_storage
+      raise NotImplementedError
+    end
+  end
+
+  # @!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
@@ -57,33 +115,25 @@ class ThreadLocalVar
     #   array, so we don't leak memory
 
     # @!visibility private
-    NIL_SENTINEL = Object.new
     FREE = []
     LOCK = Mutex.new
     ARRAYS = {} # used as a hash set
     @@next = 0
-    private_constant :NIL_SENTINEL, :FREE, :LOCK, :ARRAYS
+    private_constant :FREE, :LOCK, :ARRAYS
 
+    # @!macro [attach] thread_local_var_method_initialize
+    #
     #   Creates a thread local variable.
     #
     #   @param [Object] default the default value when otherwise unset
     def initialize(default = nil)
       @default = default
-      @index = LOCK.synchronize do
-        FREE.pop || begin
-          result = @@next
-          @@next += 1
-          result
-        end
-      end
-      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
+      allocate_storage
     end
 
-    #   Returns the value in the current thread's copy of this thread-local variable.
-    #
-    #   @return [Object] the current value
+    # @!macro thread_local_var_method_get
     def value
-      if array = Thread.current[:__threadlocal_array__]
+      if array = Thread.current.thread_variable_get(:__threadlocal_array__)
         value = array[@index]
         if value.nil?
           @default
@@ -97,30 +147,22 @@ def value
       end
     end
 
-    #   Sets the current thread's copy of this thread-local variable to the specified value.
-    #
-    #   @param [Object] value the value to set
-    #   @return [Object] the new value
+    # @!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 = me[:__threadlocal_array__]
-        array = me[:__threadlocal_array__] = []
+      unless array = me.thread_variable_get(:__threadlocal_array__)
+        array = me.thread_variable_set(:__threadlocal_array__, [])
         LOCK.synchronize { ARRAYS[array.object_id] = array }
         ObjectSpace.define_finalizer(me, self.class.thread_finalizer(array))
       end
       array[@index] = (value.nil? ? NIL_SENTINEL : value)
       value
     end
 
-    #   Bind the given value to thread local storage during
-    #   execution of the given block.
-    #
-    #   @param [Object] value the value to bind
-    #   @yield the operation to be performed with the bound variable
-    #   @return [Object] the value
+    # @!macro thread_local_var_method_bind
     def bind(value, &block)
       if block_given?
         old_value = self.value
@@ -135,6 +177,18 @@ def bind(value, &block)
 
     protected
 
+    # @!visibility private
+    def allocate_storage
+      @index = LOCK.synchronize do
+        FREE.pop || begin
+        result = @@next
+        @@next += 1
+        result
+        end
+      end
+      ObjectSpace.define_finalizer(self, self.class.threadlocal_finalizer(@index))
+    end
+
     # @!visibility private
     def self.threadlocal_finalizer(index)
       proc do
@@ -160,43 +214,78 @@ def self.thread_finalizer(array)
         end
       end
     end
+  end
 
-    private
+  if Concurrent.on_jruby?
 
-    # This exists only for use in testing
     # @!visibility private
-    def value_for(thread)
-      if array = thread[:__threadlocal_array__]
-        value = array[@index]
+    # @!macro internal_implementation_note
+    class JavaThreadLocalVar < AbstractThreadLocalVar
+
+      # @!macro thread_local_var_method_get
+      def value
+        value = @var.get
+
         if value.nil?
           @default
-        elsif value.equal?(NIL_SENTINEL)
+        elsif value == NIL_SENTINEL
           nil
         else
           value
         end
-      else
-        @default
       end
-    end
 
-    private
+      # @!macro thread_local_var_method_set
+      def value=(value)
+        @var.set(value)
+      end
 
-    # This exists only for use in testing
-    # @!visibility private
-    def value_for(thread)
-      if array = thread[:__threadlocal_array__]
-        value = array[@index]
-        if value.nil?
-          @default
-        elsif value.equal?(NIL_SENTINEL)
-          nil
-        else
-          value
+      # @!macro thread_local_var_method_bind
+      def bind(value, &block)
+        if block_given?
+          old_value = @var.get
+          begin
+            @var.set(value)
+            yield
+          ensure
+            @var.set(old_value)
+          end
         end
-      else
-        @default
+      end
+
+      protected
+
+      # @!visibility private
+      def allocate_storage
+        @var = java.lang.ThreadLocal.new
       end
     end
   end
+
+  # @!visibility private
+  # @!macro internal_implementation_note
+  ThreadLocalVarImplementation = case
+                                 when Concurrent.on_jruby?
+                                   JavaThreadLocalVar
+                                 else
+                                   RubyThreadLocalVar
+                                 end
+  private_constant :ThreadLocalVarImplementation
+
+  # @!macro thread_local_var
+  class ThreadLocalVar < ThreadLocalVarImplementation
+
+    # @!method initialize(default = nil)
+    #   @!macro thread_local_var_method_initialize
+
+    # @!method value
+    #   @!macro thread_local_var_method_get
+
+    # @!method value=(value)
+    #   @!macro thread_local_var_method_set
+
+    # @!method bind(value, &block)
+    #   @!macro thread_local_var_method_bind
+
+  end
 end

spec/concurrent/atomic/thread_local_var_spec.rb

@@ -27,6 +27,16 @@ module Concurrent
         expect(t1.value).to eq 14
         expect(t2.value).to eq 14
       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
+      end
     end
 
     context '#value' do
@@ -37,17 +47,16 @@ module Concurrent
       end
 
       it 'returns the value after modification' do
-        v       = ThreadLocalVar.new(14)
+        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 = ThreadLocalVar.new(14)
         v.value = 2
         expect(v.value).to eq 2
       end
@@ -58,14 +67,14 @@ module Concurrent
       end
 
       it 'does not modify the initial value for other threads' do
-        v       = ThreadLocalVar.new(14)
+        v = ThreadLocalVar.new(14)
         v.value = 2
-        t       = Thread.new { v.value }
+        t = Thread.new { v.value }
         expect(t.value).to eq 14
       end
 
       it 'does not modify the value for other threads' do
-        v       = ThreadLocalVar.new(14)
+        v = ThreadLocalVar.new(14)
         v.value = 2
 
         b1 = CountDownLatch.new(2)
@@ -92,9 +101,6 @@ module Concurrent
         expect(t1.value).to eq 1
         expect(t2.value).to eq 2
       end
-
     end
-
   end
-
 end