Allow ThreadLocalVar to be initialized with a block

ThreadLocalVars can now receive a block in the #initialize method,
which will be called to initialize the value on each thread.

This allows default initialization to work with non-value types, where
each thread gets its own copy:

    v = ThreadLocalVar.new { {} }
    h1 = Thread.new { v.value }.value
    h2 = Thread.new { v.value }.value

    h1.equal? h2 # -> false

Author: ivoanjo

lib/concurrent/atomic/abstract_thread_local_var.rb

@@ -8,8 +8,17 @@ module Concurrent
   class AbstractThreadLocalVar
 
     # @!macro thread_local_var_method_initialize
-    def initialize(default = nil)
-      @default = default
+    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
+      else
+        @default = default
+      end
+
       allocate_storage
     end
 
@@ -42,5 +51,14 @@ def bind(value, &block)
     def allocate_storage
       raise NotImplementedError
     end
+
+    # @!visibility private
+    def default
+      if @default_block
+        self.value = @default_block.call
+      else
+        @default
+      end
+    end
   end
 end

lib/concurrent/atomic/java_thread_local_var.rb

@@ -13,7 +13,7 @@ def value
         value = @var.get
 
         if value.nil?
-          @default
+          default
         elsif value == NULL
           nil
         else

lib/concurrent/atomic/ruby_thread_local_var.rb

@@ -40,14 +40,14 @@ def value
       if array = get_threadlocal_array
         value = array[@index]
         if value.nil?
-          @default
+          default
         elsif value.equal?(NULL)
           nil
         else
           value
         end
       else
-        @default
+        default
       end
     end
 
@@ -135,12 +135,20 @@ def value_for(thread)
       if array = get_threadlocal_array(thread)
         value = array[@index]
         if value.nil?
-          @default
+          default_for(thread)
         elsif value.equal?(NULL)
           nil
         else
           value
         end
+      else
+        default_for(thread)
+      end
+    end
+
+    def default_for(thread)
+      if @default_block
+        raise "Cannot use default_for with default block"
       else
         @default
       end

lib/concurrent/atomic/thread_local_var.rb

@@ -11,6 +11,8 @@ module Concurrent
   #   Creates a thread local variable.
   #
   #   @param [Object] default the default value when otherwise unset
+  #   @param [Proc] block Optional block that gets called to obtain the
+  #     default value for each thread
 
   # @!macro [new] thread_local_var_method_get
   #

spec/concurrent/atomic/thread_local_var_spec.rb

@@ -35,6 +35,17 @@ module Concurrent
           expect(described_class.ancestors).to include(Concurrent::RubyThreadLocalVar)
         end
       end
+
+      it 'can set a block to be called to get the initial value' do
+        v = described_class.new { 14 }
+        expect(v.value).to eq 14
+      end
+
+      context 'when attempting to set both an initial value and a block' do
+        it do
+          expect { described_class.new(14) { 14 } }.to raise_error(ArgumentError)
+        end
+      end
     end
 
     context '#value' do
@@ -48,6 +59,36 @@ module Concurrent
         v.value = 2
         expect(v.value).to eq 2
       end
+
+      context 'when using a block to initialize the value' do
+        it 'calls the block to initialize the value' do
+          block = proc { }
+
+          expect(block).to receive(:call)
+
+          v = described_class.new(&block)
+          v.value
+        end
+
+        it 'sets the block return value as the current value' do
+          value = 13
+
+          v = described_class.new { value += 1 }
+
+          v.value
+          expect(v.value).to be 14
+        end
+
+        it 'calls the block to initialize the value for each thread' do
+          block = proc { }
+
+          expect(block).to receive(:call).twice
+
+          v = described_class.new(&block)
+          Thread.new { v.value }.join
+          Thread.new { v.value }.join
+        end
+      end
     end
 
     context '#value=' do