tool 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 725ca5923dffd3a0ae1191c35fd80011f341750b
-  data.tar.gz: a09be4b173b7bd8aa8a8d2281ef2b2e274714ca8
+  metadata.gz: 3ad22826371837ebdeb6a642c310bf0b02815139
+  data.tar.gz: b16dc92838a3bb4776664d4cce4a868d3bf36067
 SHA512:
-  metadata.gz: c28c6074f6bbb5827825f4376ad9c4866661988fbc9247a74488122cb71faf30ce46e26a6e84cdea20259c000acf9d49bdbe70aef7c375d30e112fec1bf1e2fd
-  data.tar.gz: bfc3a87def2d13a293ded338fc9e4c3f3a2e6ebe3cc3faaf71ed922c8c69e4499a58eda3d08f59e1d22cffae6c7e842bf2a9e34332bd11d3a31bd670fe8c1efd
+  metadata.gz: 4e68bf215746003f18c31579c68b31993821d82aa55fd0933633da2955139e5a169ad72d16cffb2fdd1f735452956292401d598018f86d0aa90ff1db252bc720
+  data.tar.gz: 4aea8b0920a9e735b9fa3a2548b7562517be8841b3cd7bac2011d4e782346e4841006bf43c94a81fc382fd4b819ade7d7392589844fc84c8090ebba5b3099d86

data/README.md

@@ -7,4 +7,4 @@ Included:
 * **Decoration** - Mixin for easy method decorations.
 * **EqualityMap** - Weak reference caching based on key equality.
 * **ThreadLocal** - True thread locals that are properly garbage collected.
-* **WarningFilter** - Enable Ruby's warnings, but filter out caused by third party gems.
+* **WarningFilter** - Enable Ruby's warnings, but filter out those caused by third party gems.

data/lib/tool/thread_local.rb

@@ -29,17 +29,59 @@ module Tool
   #   Thread.new { p local }.join # [:foo]
   #   p local # [:foo, :bar]
   class ThreadLocal < Delegator
+    @mutex  ||= Mutex.new
+    @locals ||= []
+
+    # Thread finalizer.
+    # @!visibility private
+    def self.cleanup(id)
+      @locals.keep_if do |local|
+        next false unless local.weakref_alive?
+        local.__cleanup__
+        true
+      end
+    end
+
+    # Generates weak reference to thread and sets up finalizer.
+    # @return [WeakRef]
+    # @!visibility private
+    def self.ref(thread)
+      thread[:weakref] ||= begin
+        ObjectSpace.define_finalizer(thread, method(:cleanup))
+        WeakRef.new(thread)
+      end
+    end
+
+    # @see #initialize
+    # @!visibility private
+    def self.new(*)
+      result = super(default)
+      @mutex.synchronize { @locals << WeakRef.new(result) }
+      result
+    end
+
     def initialize(default = {})
-      @mutex = Mutex.new
       @default = default.dup
-      @map = {}
+      @map     = {}
     end
 
+    # @see Delegator
     # @!visibility private
     def __getobj__
-      ref = Thread.current[:weakref] ||= WeakRef.new(Thread.current)
-      @map.delete_if { |key, value| !key.weakref_alive? }
-      @mutex.synchronize { @map[ref] ||= @default.dup }
+      ref = ::Tool::ThreadLocal.ref(Thread.current)
+      @map[ref] ||= @default.dup
+    end
+
+    # @return [Integer] number of threads with specific locals
+    # @!visibility private
+    def __size__
+      @map.size
+    end
+
+    # Remove locals for dead or GC'ed threads
+    # @!visibility private
+    def __cleanup__
+      @map.keep_if { |key, value| key.weakref_alive? and key.alive? }
     end
   end
 end

data/lib/tool/version.rb

@@ -1,3 +1,3 @@
 module Tool
-  VERSION = '0.2.0'
+  VERSION = '0.2.1'
 end

data/spec/thread_local_spec.rb

@@ -1,26 +1,71 @@
 require 'tool/thread_local'
 
 describe Tool::ThreadLocal do
-  specify 'normal access' do
-    subject[:foo] = 'bar'
-    expect(subject[:foo]).to be == 'bar'
-  end
+  describe :__getobj__ do
+    specify 'normal access' do
+      subject[:foo] = 'bar'
+      expect(subject[:foo]).to be == 'bar'
+    end
+
+    specify 'concurrent access' do
+      subject[:foo] = 'bar'
+      value = Thread.new { subject[:foo] = 'baz' }.value
+      expect(value).to be == 'baz'
+      expect(subject[:foo]).to be == 'bar'
+    end
+
+    specify 'with an array as value' do
+      list = Tool::ThreadLocal.new([])
+      foo  = Thread.new { 10.times { list << :foo; sleep(0.01) }; list.to_a }
+      bar  = Thread.new { 10.times { list << :bar; sleep(0.01) }; list.to_a }
+      expect(list).to be_empty
+      list << :list
+      expect(list)      .to be == [ :list ]
+      expect(foo.value) .to be == [ :foo  ] * 10
+      expect(bar.value) .to be == [ :bar  ] * 10
+    end
+
+    specify 'deals with garbage collected threads' do
+      subject[:a] = 'A'
+
+      Thread.new do
+        subject[:b] = 'B'
+        Thread.new do
+          subject[:c] = 'C'
+        end.value
+      end.value
 
-  specify 'concurrent access' do
-    subject[:foo] = 'bar'
-    value = Thread.new { subject[:foo] = 'baz' }.value
-    expect(value).to be == 'baz'
-    expect(subject[:foo]).to be == 'bar'
+      GC.start
+      expect(subject[:a]).to be == 'A'
+    end
   end
 
-  specify 'with an array as value' do
-    list = Tool::ThreadLocal.new([])
-    foo  = Thread.new { 10.times { list << :foo; sleep(0.01) }; list.to_a }
-    bar  = Thread.new { 10.times { list << :bar; sleep(0.01) }; list.to_a }
-    expect(list).to be_empty
-    list << :list
-    expect(list)      .to be == [ :list ]
-    expect(foo.value) .to be == [ :foo  ] * 10
-    expect(bar.value) .to be == [ :bar  ] * 10
+  describe :__size__ do
+    specify 'with one thread' do
+      subject[:a] = 'A'
+      expect(subject.__size__).to be == 1
+    end
+
+    specify 'with multiple threads' do
+      subject[:a] = 'A'
+      thread = Thread.new { subject[:b] = 'B'; sleep }
+      sleep 0.01
+      expect(subject.__size__).to be == 2
+      thread.kill
+    end
+
+    specify 'with dead threads' do
+      subject[:a] = 'A'
+
+      Thread.new do
+        subject[:b] = 'B'
+        Thread.new do
+          subject[:c] = 'C'
+        end.value
+      end.value
+
+      GC.start
+      expect(subject.__size__).to be == 1
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tool
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Konstantin Haase
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-22 00:00:00.000000000 Z
+date: 2014-02-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec