thread_safe 0.3.1-java → 0.3.2-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd78f6716a19a528d4f244f47944740468398978
-  data.tar.gz: 92d44fadb74cb932282e682967b11c532ad7a678
+  metadata.gz: 011bc3a02316bba0bb69f2aeaaf95d72d14c25a5
+  data.tar.gz: 27e578528177719a9eb1ac72727c3f84c053c484
 SHA512:
-  metadata.gz: 50cd42d6dfaa8f703d9fe3034150b3012317d1af47690c88a1c906196760ccd3eafd4afa1f925c946a8842f026cb7ccec00056fdb3bcaff3ed00657fa9db8508
-  data.tar.gz: dddfe11774caf6f080292540c11cf795d9e8867d6917da1e2ff9d907fbb9e2eafa3b47ca6e9dcf5e07f2498c53bf238c6771df9e79540f310ae6ac3ef30bbd19
+  metadata.gz: 1e821f7904a0bac53fc7d0a5854ee442daffc75aebed26e216f4f58f3c21a87e6b71bac97fbea8ecf074725ef8c3b0dc3eda741999580539e570afa3857a0c30
+  data.tar.gz: 4b49dc4c12fd055deefe80e21ee38567dbdfb74dd36b51e85bdf80c252465cadbab8aec826dcea71b23c1bf7f120ba45d6bf8243015e573272893be450fd93ab

data/lib/thread_safe/synchronized_delegator.rb

@@ -16,6 +16,14 @@ require 'monitor'
 # This class is currently being considered for inclusion into stdlib, via
 # https://bugs.ruby-lang.org/issues/8556
 class SynchronizedDelegator < SimpleDelegator
+  def setup
+    @old_abort = Thread.abort_on_exception
+    Thread.abort_on_exception = true
+  end
+
+  def teardown
+    Thread.abort_on_exception = @old_abort
+  end
 
   def initialize(obj)
     __setobj__(obj)

data/lib/thread_safe/util/atomic_reference.rb

@@ -1,12 +1,45 @@
 module ThreadSafe
   module Util
-    # An overhead-less atomic reference.
     AtomicReference =
       if defined?(Rubinius::AtomicReference)
+        # An overhead-less atomic reference.
         Rubinius::AtomicReference
       else
-        require 'atomic'
-        defined?(Atomic::InternalReference) ? Atomic::InternalReference : Atomic
+        begin
+          require 'atomic'
+          defined?(Atomic::InternalReference) ? Atomic::InternalReference : Atomic
+        rescue NameError
+          require 'thread' # get Mutex on 1.8
+          class FullLockingAtomicReference
+            def initialize(value = nil)
+              @___mutex = Mutex.new
+              @___value = value
+            end
+
+            def get
+              @___mutex.synchronize { @___value }
+            end
+            alias_method :value, :get
+
+            def set(new_value)
+              @___mutex.synchronize { @___value = new_value }
+            end
+            alias_method :value=, :set
+
+            def compare_and_set(old_value, new_value)
+              return false unless @___mutex.try_lock
+              begin
+                return false unless @___value.equal? old_value
+                @___value = new_value
+              ensure
+                @___mutex.unlock
+              end
+              true
+            end
+          end
+
+          FullLockingAtomicReference
+        end
       end
   end
 end

data/lib/thread_safe/version.rb

@@ -1,5 +1,5 @@
 module ThreadSafe
-  VERSION = "0.3.1"
+  VERSION = "0.3.2"
 end
 
 # NOTE: <= 0.2.0 used Threadsafe::VERSION

data/test/test_cache_loops.rb

@@ -5,450 +5,448 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 Thread.abort_on_exception = true
 
-unless RUBY_VERSION =~ /1\.8/ || ENV['TRAVIS']
-  class TestCacheTorture < Test::Unit::TestCase
-    THREAD_COUNT  = 40
-    KEY_COUNT     = (((2**13) - 2) * 0.75).to_i # get close to the doubling cliff
-    LOW_KEY_COUNT = (((2**8 ) - 2) * 0.75).to_i # get close to the doubling cliff
-
-    INITIAL_VALUE_CACHE_SETUP = lambda do |options, keys|
-      cache         = ThreadSafe::Cache.new
-      initial_value = options[:initial_value] || 0
-      keys.each {|key| cache[key] = initial_value}
-      cache
-    end
-    ZERO_VALUE_CACHE_SETUP = lambda do |options, keys|
-      INITIAL_VALUE_CACHE_SETUP.call(options.merge(:initial_value => 0), keys)
-    end
+class TestCacheTorture < Test::Unit::TestCase # this is not run unless RUBY_VERSION =~ /1\.8/ || ENV['TRAVIS'] (see the end of the file)
+  THREAD_COUNT  = 40
+  KEY_COUNT     = (((2**13) - 2) * 0.75).to_i # get close to the doubling cliff
+  LOW_KEY_COUNT = (((2**8 ) - 2) * 0.75).to_i # get close to the doubling cliff
+
+  INITIAL_VALUE_CACHE_SETUP = lambda do |options, keys|
+    cache         = ThreadSafe::Cache.new
+    initial_value = options[:initial_value] || 0
+    keys.each {|key| cache[key] = initial_value}
+    cache
+  end
+  ZERO_VALUE_CACHE_SETUP = lambda do |options, keys|
+    INITIAL_VALUE_CACHE_SETUP.call(options.merge(:initial_value => 0), keys)
+  end
 
-    DEFAULTS = {
-      :key_count    => KEY_COUNT,
-      :thread_count => THREAD_COUNT,
-      :loop_count   => 1,
-      :prelude      => '',
-      :cache_setup  => lambda {|options, keys| ThreadSafe::Cache.new}
-    }
-
-    LOW_KEY_COUNT_OPTIONS    = {:loop_count => 150,     :key_count => LOW_KEY_COUNT}
-    SINGLE_KEY_COUNT_OPTIONS = {:loop_count => 100_000, :key_count => 1}
-
-    def test_concurrency
-      code = <<-RUBY_EVAL
-	cache[key]
-	cache[key] = key
-	cache[key]
-	cache.delete(key)
-      RUBY_EVAL
-      do_thread_loop(:concurrency, code)
-    end
+  DEFAULTS = {
+    :key_count    => KEY_COUNT,
+    :thread_count => THREAD_COUNT,
+    :loop_count   => 1,
+    :prelude      => '',
+    :cache_setup  => lambda {|options, keys| ThreadSafe::Cache.new}
+  }
+
+  LOW_KEY_COUNT_OPTIONS    = {:loop_count => 150,     :key_count => LOW_KEY_COUNT}
+  SINGLE_KEY_COUNT_OPTIONS = {:loop_count => 100_000, :key_count => 1}
+
+  def test_concurrency
+    code = <<-RUBY_EVAL
+      cache[key]
+      cache[key] = key
+      cache[key]
+      cache.delete(key)
+    RUBY_EVAL
+    do_thread_loop(__method__, code)
+  end
 
-    def test_put_if_absent
-      do_thread_loop(:put_if_absent, 'acc += 1 unless cache.put_if_absent(key, key)', :key_count => 100_000) do |result, cache, options, keys|
-	assert_standard_accumulator_test_result(result, cache, options, keys)
-      end
+  def test_put_if_absent
+    do_thread_loop(__method__, 'acc += 1 unless cache.put_if_absent(key, key)', :key_count => 100_000) do |result, cache, options, keys|
+      assert_standard_accumulator_test_result(result, cache, options, keys)
     end
+  end
 
-    def test_compute_if_absent
-      code = 'cache.compute_if_absent(key) { acc += 1; key }'
-      do_thread_loop(:compute_if_absent, code) do |result, cache, options, keys|
-	assert_standard_accumulator_test_result(result, cache, options, keys)
-      end
+  def test_compute_if_absent
+    code = 'cache.compute_if_absent(key) { acc += 1; key }'
+    do_thread_loop(__method__, code) do |result, cache, options, keys|
+      assert_standard_accumulator_test_result(result, cache, options, keys)
     end
+  end
 
-    def test_compute_put_if_absent
-      code = <<-RUBY_EVAL
-	if key.even?
-	  cache.compute_if_absent(key) { acc += 1; key }
-	else
-	  acc += 1 unless cache.put_if_absent(key, key)
-	end
-      RUBY_EVAL
-      do_thread_loop(:compute_put_if_absent, code) do |result, cache, options, keys|
-	assert_standard_accumulator_test_result(result, cache, options, keys)
+  def test_compute_put_if_absent
+    code = <<-RUBY_EVAL
+      if key.even?
+        cache.compute_if_absent(key) { acc += 1; key }
+      else
+        acc += 1 unless cache.put_if_absent(key, key)
       end
+    RUBY_EVAL
+    do_thread_loop(__method__, code) do |result, cache, options, keys|
+      assert_standard_accumulator_test_result(result, cache, options, keys)
     end
+  end
 
-    def test_compute_if_absent_and_present
-      compute_if_absent_and_present
-      compute_if_absent_and_present(LOW_KEY_COUNT_OPTIONS)
-      compute_if_absent_and_present(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_compute_if_absent_and_present
+    compute_if_absent_and_present
+    compute_if_absent_and_present(LOW_KEY_COUNT_OPTIONS)
+    compute_if_absent_and_present(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_add_remove_to_zero
-      add_remove_to_zero
-      add_remove_to_zero(LOW_KEY_COUNT_OPTIONS)
-      add_remove_to_zero(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_add_remove_to_zero
+    add_remove_to_zero
+    add_remove_to_zero(LOW_KEY_COUNT_OPTIONS)
+    add_remove_to_zero(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_add_remove_to_zero_via_merge_pair
-      add_remove_to_zero_via_merge_pair
-      add_remove_to_zero_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
-      add_remove_to_zero_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_add_remove_to_zero_via_merge_pair
+    add_remove_to_zero_via_merge_pair
+    add_remove_to_zero_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
+    add_remove_to_zero_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_add_remove
-      add_remove
-      add_remove(LOW_KEY_COUNT_OPTIONS)
-      add_remove(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_add_remove
+    add_remove
+    add_remove(LOW_KEY_COUNT_OPTIONS)
+    add_remove(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_add_remove_via_compute
-      add_remove_via_compute
-      add_remove_via_compute(LOW_KEY_COUNT_OPTIONS)
-      add_remove_via_compute(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_add_remove_via_compute
+    add_remove_via_compute
+    add_remove_via_compute(LOW_KEY_COUNT_OPTIONS)
+    add_remove_via_compute(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def add_remove_via_compute_if_absent_present
-      add_remove_via_compute_if_absent_present
-      add_remove_via_compute_if_absent_present(LOW_KEY_COUNT_OPTIONS)
-      add_remove_via_compute_if_absent_present(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def add_remove_via_compute_if_absent_present
+    add_remove_via_compute_if_absent_present
+    add_remove_via_compute_if_absent_present(LOW_KEY_COUNT_OPTIONS)
+    add_remove_via_compute_if_absent_present(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_add_remove_indiscriminate
-      add_remove_indiscriminate
-      add_remove_indiscriminate(LOW_KEY_COUNT_OPTIONS)
-      add_remove_indiscriminate(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_add_remove_indiscriminate
+    add_remove_indiscriminate
+    add_remove_indiscriminate(LOW_KEY_COUNT_OPTIONS)
+    add_remove_indiscriminate(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_count_up
-      count_up
-      count_up(LOW_KEY_COUNT_OPTIONS)
-      count_up(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_count_up
+    count_up
+    count_up(LOW_KEY_COUNT_OPTIONS)
+    count_up(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_count_up_via_compute
-      count_up_via_compute
-      count_up_via_compute(LOW_KEY_COUNT_OPTIONS)
-      count_up_via_compute(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_count_up_via_compute
+    count_up_via_compute
+    count_up_via_compute(LOW_KEY_COUNT_OPTIONS)
+    count_up_via_compute(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_count_up_via_merge_pair
-      count_up_via_merge_pair
-      count_up_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
-      count_up_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
-    end
+  def test_count_up_via_merge_pair
+    count_up_via_merge_pair
+    count_up_via_merge_pair(LOW_KEY_COUNT_OPTIONS)
+    count_up_via_merge_pair(SINGLE_KEY_COUNT_OPTIONS)
+  end
 
-    def test_count_race
-      prelude = 'change = (rand(2) == 1) ? 1 : -1'
-      code = <<-RUBY_EVAL
-	v = cache[key]
-	acc += change if cache.replace_pair(key, v, v + change)
-      RUBY_EVAL
-      do_thread_loop(:count_race, code, :loop_count => 5, :prelude => prelude, :cache_setup => ZERO_VALUE_CACHE_SETUP) do |result, cache, options, keys|
-	result_sum = sum(result)
-	assert_equal(sum(keys.map {|key| cache[key]}), result_sum)
-	assert_equal(sum(cache.values), result_sum)
-	assert_equal(options[:key_count], cache.size)
-      end
+  def test_count_race
+    prelude = 'change = (rand(2) == 1) ? 1 : -1'
+    code = <<-RUBY_EVAL
+      v = cache[key]
+      acc += change if cache.replace_pair(key, v, v + change)
+    RUBY_EVAL
+    do_thread_loop(__method__, code, :loop_count => 5, :prelude => prelude, :cache_setup => ZERO_VALUE_CACHE_SETUP) do |result, cache, options, keys|
+      result_sum = sum(result)
+      assert_equal(sum(keys.map {|key| cache[key]}), result_sum)
+      assert_equal(sum(cache.values), result_sum)
+      assert_equal(options[:key_count], cache.size)
     end
+  end
 
-    def test_get_and_set_new
-      code = 'acc += 1 unless cache.get_and_set(key, key)'
-      do_thread_loop(:get_and_set_new, code) do |result, cache, options, keys|
-	assert_standard_accumulator_test_result(result, cache, options, keys)
-      end
+  def test_get_and_set_new
+    code = 'acc += 1 unless cache.get_and_set(key, key)'
+    do_thread_loop(__method__, code) do |result, cache, options, keys|
+      assert_standard_accumulator_test_result(result, cache, options, keys)
     end
+  end
 
-    def test_get_and_set_existing
-      code = 'acc += 1 if cache.get_and_set(key, key) == -1'
-      do_thread_loop(:get_and_set_existing, code, :cache_setup => INITIAL_VALUE_CACHE_SETUP, :initial_value => -1) do |result, cache, options, keys|
-	assert_standard_accumulator_test_result(result, cache, options, keys)
-      end
+  def test_get_and_set_existing
+    code = 'acc += 1 if cache.get_and_set(key, key) == -1'
+    do_thread_loop(__method__, code, :cache_setup => INITIAL_VALUE_CACHE_SETUP, :initial_value => -1) do |result, cache, options, keys|
+      assert_standard_accumulator_test_result(result, cache, options, keys)
     end
+  end
 
-    private
-    def compute_if_absent_and_present(opts = {})
-      prelude = 'on_present = rand(2) == 1'
-      code = <<-RUBY_EVAL
-	if on_present
-	  cache.compute_if_present(key) {|old_value| acc += 1; old_value + 1}
-	else
-	  cache.compute_if_absent(key)  { acc += 1; 1 }
-	end
-      RUBY_EVAL
-      do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
-	stored_sum       = 0
-	stored_key_count = 0
-	keys.each do |k|
-	  if value = cache[k]
-	    stored_sum += value
-	    stored_key_count += 1
-	  end
-	end
-	assert_equal(stored_sum, sum(result))
-	assert_equal(stored_key_count, cache.size)
+  private
+  def compute_if_absent_and_present(opts = {})
+    prelude = 'on_present = rand(2) == 1'
+    code = <<-RUBY_EVAL
+      if on_present
+        cache.compute_if_present(key) {|old_value| acc += 1; old_value + 1}
+      else
+        cache.compute_if_absent(key)  { acc += 1; 1 }
       end
-    end
-
-    def add_remove(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-	if do_add
-	  acc += 1 unless cache.put_if_absent(key, key)
-	else
-	  acc -= 1 if cache.delete_pair(key, key)
-	end
-      RUBY_EVAL
-      do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
-	assert_all_key_mappings_exist(cache, keys, false)
-	assert_equal(cache.size, sum(result))
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+      stored_sum       = 0
+      stored_key_count = 0
+      keys.each do |k|
+        if value = cache[k]
+          stored_sum += value
+          stored_key_count += 1
+        end
       end
+      assert_equal(stored_sum, sum(result))
+      assert_equal(stored_key_count, cache.size)
     end
+  end
 
-    def add_remove_via_compute(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-	cache.compute(key) do |old_value|
-	  if do_add
-	    acc += 1 unless old_value
-	    key
-	  else
-	    acc -= 1 if old_value
-	    nil
-	  end
-	end
-      RUBY_EVAL
-      do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
-	assert_all_key_mappings_exist(cache, keys, false)
-	assert_equal(cache.size, sum(result))
+  def add_remove(opts = {})
+    prelude = 'do_add = rand(2) == 1'
+    code = <<-RUBY_EVAL
+      if do_add
+        acc += 1 unless cache.put_if_absent(key, key)
+      else
+        acc -= 1 if cache.delete_pair(key, key)
       end
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+      assert_all_key_mappings_exist(cache, keys, false)
+      assert_equal(cache.size, sum(result))
     end
+  end
 
-    def add_remove_via_compute_if_absent_present(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-	if do_add
-	  cache.compute_if_absent(key)  { acc += 1; key }
-	else
-	  cache.compute_if_present(key) { acc -= 1; nil }
-	end
-      RUBY_EVAL
-      do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
-	assert_all_key_mappings_exist(cache, keys, false)
-	assert_equal(cache.size, sum(result))
+  def add_remove_via_compute(opts = {})
+    prelude = 'do_add = rand(2) == 1'
+    code = <<-RUBY_EVAL
+      cache.compute(key) do |old_value|
+        if do_add
+          acc += 1 unless old_value
+          key
+        else
+          acc -= 1 if old_value
+          nil
+        end
       end
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+      assert_all_key_mappings_exist(cache, keys, false)
+      assert_equal(cache.size, sum(result))
     end
+  end
 
-    def add_remove_indiscriminate(opts = {})
-      prelude = 'do_add = rand(2) == 1'
-      code = <<-RUBY_EVAL
-	if do_add
-	  acc += 1 unless cache.put_if_absent(key, key)
-	else
-	  acc -= 1 if cache.delete(key)
-	end
-      RUBY_EVAL
-      do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
-	assert_all_key_mappings_exist(cache, keys, false)
-	assert_equal(cache.size, sum(result))
+  def add_remove_via_compute_if_absent_present(opts = {})
+    prelude = 'do_add = rand(2) == 1'
+    code = <<-RUBY_EVAL
+      if do_add
+        cache.compute_if_absent(key)  { acc += 1; key }
+      else
+        cache.compute_if_present(key) { acc -= 1; nil }
       end
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+      assert_all_key_mappings_exist(cache, keys, false)
+      assert_equal(cache.size, sum(result))
     end
+  end
 
-    def count_up(opts = {})
-      code = <<-RUBY_EVAL
-	v = cache[key]
-	acc += 1 if cache.replace_pair(key, v, v + 1)
-      RUBY_EVAL
-      do_thread_loop(__method__, code, {:loop_count => 5, :cache_setup => ZERO_VALUE_CACHE_SETUP}.merge(opts)) do |result, cache, options, keys|
-	assert_count_up(result, cache, options, keys)
+  def add_remove_indiscriminate(opts = {})
+    prelude = 'do_add = rand(2) == 1'
+    code = <<-RUBY_EVAL
+      if do_add
+        acc += 1 unless cache.put_if_absent(key, key)
+      else
+        acc -= 1 if cache.delete(key)
       end
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5, :prelude => prelude}.merge(opts)) do |result, cache, options, keys|
+      assert_all_key_mappings_exist(cache, keys, false)
+      assert_equal(cache.size, sum(result))
     end
+  end
 
-    def count_up_via_compute(opts = {})
-      code = <<-RUBY_EVAL
-	cache.compute(key) do |old_value|
-	  acc += 1
-	  old_value ? old_value + 1 : 1
-	end
-      RUBY_EVAL
-      do_thread_loop(:count_up_via_compute, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
-	assert_count_up(result, cache, options, keys)
-	result.inject(nil) do |previous_value, next_value| # since compute guarantees atomicity all count ups should be equal
-	  assert_equal previous_value, next_value if previous_value
-	  next_value
-	end
-      end
+  def count_up(opts = {})
+    code = <<-RUBY_EVAL
+      v = cache[key]
+      acc += 1 if cache.replace_pair(key, v, v + 1)
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5, :cache_setup => ZERO_VALUE_CACHE_SETUP}.merge(opts)) do |result, cache, options, keys|
+      assert_count_up(result, cache, options, keys)
     end
+  end
 
-    def count_up_via_merge_pair(opts = {})
-      code = <<-RUBY_EVAL
-	cache.merge_pair(key, 1) {|old_value| old_value + 1}
-      RUBY_EVAL
-      do_thread_loop(:count_up_via_merge_pair, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
-	all_match      = true
-	expected_value = options[:loop_count] * options[:thread_count]
-	keys.each do |key|
-	  if expected_value != (value = cache[key])
-	    all_match = false
-	    break
-	  end
-	end
-	assert all_match
+  def count_up_via_compute(opts = {})
+    code = <<-RUBY_EVAL
+      cache.compute(key) do |old_value|
+        acc += 1
+        old_value ? old_value + 1 : 1
       end
-    end
-
-    def add_remove_to_zero(opts = {})
-      code = <<-RUBY_EVAL
-	acc += 1 unless cache.put_if_absent(key, key)
-	acc -= 1 if cache.delete_pair(key, key)
-      RUBY_EVAL
-      do_thread_loop(:add_remove_to_zero, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
-	assert_all_key_mappings_exist(cache, keys, false)
-	assert_equal(cache.size, sum(result))
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
+      assert_count_up(result, cache, options, keys)
+      result.inject(nil) do |previous_value, next_value| # since compute guarantees atomicity all count ups should be equal
+        assert_equal previous_value, next_value if previous_value
+        next_value
       end
     end
+  end
 
-    def add_remove_to_zero_via_merge_pair(opts = {})
-      code = <<-RUBY_EVAL
-	acc += (cache.merge_pair(key, key) {}) ? -1 : 1
-      RUBY_EVAL
-      do_thread_loop(:add_remove_to_zero_via_merge_pair, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
-	assert_all_key_mappings_exist(cache, keys, false)
-	assert_equal(cache.size, sum(result))
+  def count_up_via_merge_pair(opts = {})
+    code = <<-RUBY_EVAL
+      cache.merge_pair(key, 1) {|old_value| old_value + 1}
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
+      all_match      = true
+      expected_value = options[:loop_count] * options[:thread_count]
+      keys.each do |key|
+        if expected_value != (value = cache[key])
+          all_match = false
+          break
+        end
       end
+      assert all_match
     end
+  end
 
-    def do_thread_loop(name, code, options = {}, &block)
-      options = DEFAULTS.merge(options)
-      meth    = define_loop name, code, options[:prelude]
-      assert_nothing_raised do
-	keys = to_keys_array(options[:key_count])
-	run_thread_loop(meth, keys, options, &block)
-
-	if options[:key_count] > 1
-	  options[:key_count] = (options[:key_count] / 40).to_i
-	  keys = to_hash_collision_keys_array(options[:key_count])
-	  run_thread_loop(meth, keys, options.merge(:loop_count => (options[:loop_count] * 5)), &block)
-	end
-      end
+  def add_remove_to_zero(opts = {})
+    code = <<-RUBY_EVAL
+      acc += 1 unless cache.put_if_absent(key, key)
+      acc -= 1 if cache.delete_pair(key, key)
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
+      assert_all_key_mappings_exist(cache, keys, false)
+      assert_equal(cache.size, sum(result))
     end
+  end
 
-    def run_thread_loop(meth, keys, options)
-      cache   = options[:cache_setup].call(options, keys)
-      barrier = ThreadSafe::Test::Barrier.new(options[:thread_count])
-      result = (1..options[:thread_count]).map do
-	Thread.new do
-	  setup_sync_and_start_loop(meth, cache, keys, barrier, options[:loop_count])
-	end
-      end.map(&:value)
-      yield result, cache, options, keys if block_given?
+  def add_remove_to_zero_via_merge_pair(opts = {})
+    code = <<-RUBY_EVAL
+      acc += (cache.merge_pair(key, key) {}) ? 1 : -1
+    RUBY_EVAL
+    do_thread_loop(__method__, code, {:loop_count => 5}.merge(opts)) do |result, cache, options, keys|
+      assert_all_key_mappings_exist(cache, keys, false)
+      assert_equal(cache.size, sum(result))
     end
+  end
 
-    def setup_sync_and_start_loop(meth, cache, keys, barrier, loop_count)
-      my_keys = keys.shuffle
-      barrier.await
-      if my_keys.size == 1
-	key = my_keys.first
-	send("#{meth}_single_key", cache, key, loop_count)
-      else
-	send("#{meth}_multiple_keys", cache, my_keys, loop_count)
+  def do_thread_loop(name, code, options = {}, &block)
+    options = DEFAULTS.merge(options)
+    meth    = define_loop name, code, options[:prelude]
+    assert_nothing_raised do
+      keys = to_keys_array(options[:key_count])
+      run_thread_loop(meth, keys, options, &block)
+
+      if options[:key_count] > 1
+        options[:key_count] = (options[:key_count] / 40).to_i
+        keys = to_hash_collision_keys_array(options[:key_count])
+        run_thread_loop(meth, keys, options.merge(:loop_count => (options[:loop_count] * 5)), &block)
       end
     end
+  end
 
-    def define_loop(name, body, prelude)
-      inner_meth_name = :"_#{name}_loop_inner"
-      outer_meth_name = :"_#{name}_loop_outer"
-      # looping is splitted into the "loop methods" to trigger the JIT
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-	def #{inner_meth_name}_multiple_keys(cache, keys, i, length, acc)
-	  #{prelude}
-	  target = i + length
-	  while i < target
-	    key = keys[i]
-	    #{body}
-	    i += 1
-	  end
-	  acc
-	end unless method_defined?(:#{inner_meth_name}_multiple_keys)
-      RUBY_EVAL
-
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-	def #{inner_meth_name}_single_key(cache, key, i, length, acc)
-	  #{prelude}
-	  target = i + length
-	  while i < target
-	    #{body}
-	    i += 1
-	  end
-	  acc
-	end unless method_defined?(:#{inner_meth_name}_single_key)
-      RUBY_EVAL
-
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-	def #{outer_meth_name}_multiple_keys(cache, keys, loop_count)
-	  total_length = keys.size
-	  acc = 0
-	  inc = 100
-	  loop_count.times do
-	    i = 0
-	    pre_loop_inc = total_length % inc
-	    acc = #{inner_meth_name}_multiple_keys(cache, keys, i, pre_loop_inc, acc)
-	    i += pre_loop_inc
-	    while i < total_length
-	      acc = #{inner_meth_name}_multiple_keys(cache, keys, i, inc, acc)
-	      i += inc
-	    end
-	  end
-	  acc
-	end unless method_defined?(:#{outer_meth_name}_multiple_keys)
-      RUBY_EVAL
-
-      self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-	def #{outer_meth_name}_single_key(cache, key, loop_count)
-	  acc = 0
-	  i   = 0
-	  inc = 100
-
-	  pre_loop_inc = loop_count % inc
-	  acc          = #{inner_meth_name}_single_key(cache, key, i, pre_loop_inc, acc)
-	  i += pre_loop_inc
-
-	  while i < loop_count
-	    acc = #{inner_meth_name}_single_key(cache, key, i, inc, acc)
-	    i += inc
-	  end
-	  acc
-	end unless method_defined?(:#{outer_meth_name}_single_key)
-      RUBY_EVAL
-      outer_meth_name
-    end
+  def run_thread_loop(meth, keys, options)
+    cache   = options[:cache_setup].call(options, keys)
+    barrier = ThreadSafe::Test::Barrier.new(options[:thread_count])
+    result = (1..options[:thread_count]).map do
+      Thread.new do
+        setup_sync_and_start_loop(meth, cache, keys, barrier, options[:loop_count])
+      end
+    end.map(&:value)
+    yield result, cache, options, keys if block_given?
+  end
 
-    def to_keys_array(key_count)
-      arr = []
-      key_count.times {|i| arr << i}
-      arr
+  def setup_sync_and_start_loop(meth, cache, keys, barrier, loop_count)
+    my_keys = keys.shuffle
+    barrier.await
+    if my_keys.size == 1
+      key = my_keys.first
+      send("#{meth}_single_key", cache, key, loop_count)
+    else
+      send("#{meth}_multiple_keys", cache, my_keys, loop_count)
     end
+  end
 
-    def to_hash_collision_keys_array(key_count)
-      to_keys_array(key_count).map {|key| ThreadSafe::Test::HashCollisionKey(key)}
-    end
+  def define_loop(name, body, prelude)
+    inner_meth_name = :"_#{name}_loop_inner"
+    outer_meth_name = :"_#{name}_loop_outer"
+    # looping is splitted into the "loop methods" to trigger the JIT
+    self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      def #{inner_meth_name}_multiple_keys(cache, keys, i, length, acc)
+        #{prelude}
+        target = i + length
+        while i < target
+          key = keys[i]
+          #{body}
+          i += 1
+        end
+        acc
+      end unless method_defined?(:#{inner_meth_name}_multiple_keys)
+    RUBY_EVAL
+
+    self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      def #{inner_meth_name}_single_key(cache, key, i, length, acc)
+        #{prelude}
+        target = i + length
+        while i < target
+          #{body}
+          i += 1
+        end
+        acc
+      end unless method_defined?(:#{inner_meth_name}_single_key)
+    RUBY_EVAL
+
+    self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      def #{outer_meth_name}_multiple_keys(cache, keys, loop_count)
+        total_length = keys.size
+        acc = 0
+        inc = 100
+        loop_count.times do
+          i = 0
+          pre_loop_inc = total_length % inc
+          acc = #{inner_meth_name}_multiple_keys(cache, keys, i, pre_loop_inc, acc)
+          i += pre_loop_inc
+          while i < total_length
+            acc = #{inner_meth_name}_multiple_keys(cache, keys, i, inc, acc)
+            i += inc
+          end
+        end
+        acc
+      end unless method_defined?(:#{outer_meth_name}_multiple_keys)
+    RUBY_EVAL
+
+    self.class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+      def #{outer_meth_name}_single_key(cache, key, loop_count)
+        acc = 0
+        i   = 0
+        inc = 100
+
+        pre_loop_inc = loop_count % inc
+        acc          = #{inner_meth_name}_single_key(cache, key, i, pre_loop_inc, acc)
+        i += pre_loop_inc
+
+        while i < loop_count
+          acc = #{inner_meth_name}_single_key(cache, key, i, inc, acc)
+          i += inc
+        end
+        acc
+      end unless method_defined?(:#{outer_meth_name}_single_key)
+    RUBY_EVAL
+    outer_meth_name
+  end
 
-    def sum(result)
-      result.inject(0) {|acc, i| acc + i}
-    end
+  def to_keys_array(key_count)
+    arr = []
+    key_count.times {|i| arr << i}
+    arr
+  end
 
-    def assert_standard_accumulator_test_result(result, cache, options, keys)
-      assert_all_key_mappings_exist(cache, keys)
-      assert_equal(options[:key_count], sum(result))
-      assert_equal(options[:key_count], cache.size)
-    end
+  def to_hash_collision_keys_array(key_count)
+    to_keys_array(key_count).map {|key| ThreadSafe::Test::HashCollisionKey(key)}
+  end
 
-    def assert_all_key_mappings_exist(cache, keys, all_must_exist = true)
-      keys.each do |key|
-	if (value = cache[key]) || all_must_exist
-	  assert_equal key, value unless key == value # don't do a bazzilion assertions unless necessary
-	end
+  def sum(result)
+    result.inject(0) {|acc, i| acc + i}
+  end
+
+  def assert_standard_accumulator_test_result(result, cache, options, keys)
+    assert_all_key_mappings_exist(cache, keys)
+    assert_equal(options[:key_count], sum(result))
+    assert_equal(options[:key_count], cache.size)
+  end
+
+  def assert_all_key_mappings_exist(cache, keys, all_must_exist = true)
+    keys.each do |key|
+      if (value = cache[key]) || all_must_exist
+        assert_equal key, value unless key == value # don't do a bazzilion assertions unless necessary
       end
     end
+  end
 
-    def assert_count_up(result, cache, options, keys)
-      keys.each do |key|
-	unless value = cache[key]
-	  assert value
-	end
+  def assert_count_up(result, cache, options, keys)
+    keys.each do |key|
+      unless value = cache[key]
+        assert value
       end
-      assert_equal(sum(cache.values), sum(result))
-      assert_equal(options[:key_count], cache.size)
     end
+    assert_equal(sum(cache.values), sum(result))
+    assert_equal(options[:key_count], cache.size)
   end
-end
+end unless RUBY_VERSION =~ /1\.8/ || ENV['TRAVIS']

data/test/test_synchronized_delegator.rb

@@ -2,14 +2,6 @@ require 'test/unit'
 require 'thread_safe/synchronized_delegator.rb'
 
 class TestSynchronizedDelegator < Test::Unit::TestCase
-  def setup
-    @old_abort = Thread.abort_on_exception
-    Thread.abort_on_exception = true
-  end
-
-  def teardown
-    Thread.abort_on_exception = @old_abort
-  end
 
   def test_wraps_array
     sync_array = SynchronizedDelegator.new(array = [])

data/thread_safe.gemspec

@@ -19,6 +19,6 @@ Gem::Specification.new do |gem|
   gem.version       = ThreadSafe::VERSION
   gem.license       = "Apache-2.0"
 
-  gem.add_dependency 'atomic', ['>= 1.1.7', '< 2']
+  gem.add_development_dependency 'atomic', ['>= 1.1.7', '< 2']
   gem.add_development_dependency 'rake'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thread_safe
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
 platform: java
 authors:
 - Charles Oliver Nutter
@@ -9,10 +9,11 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-03-21 00:00:00.000000000 Z
+date: 2014-04-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  name: atomic
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -20,10 +21,7 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: '2'
-  name: atomic
-  prerelease: false
-  type: :runtime
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
@@ -31,20 +29,22 @@ dependencies:
     - - <
       - !ruby/object:Gem::Version
         version: '2'
+  prerelease: false
+  type: :development
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-  name: rake
-  prerelease: false
-  type: :development
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+  prerelease: false
+  type: :development
 description: Thread-safe collections and utilities for Ruby
 email:
 - headius@headius.com
@@ -73,6 +73,7 @@ files:
 - lib/thread_safe.rb
 - lib/thread_safe/atomic_reference_cache_backend.rb
 - lib/thread_safe/cache.rb
+- lib/thread_safe/jruby_cache_backend.jar
 - lib/thread_safe/mri_cache_backend.rb
 - lib/thread_safe/non_concurrent_cache_backend.rb
 - lib/thread_safe/synchronized_cache_backend.rb
@@ -95,7 +96,6 @@ files:
 - test/test_helper.rb
 - test/test_synchronized_delegator.rb
 - thread_safe.gemspec
-- lib/thread_safe/jruby_cache_backend.jar
 homepage: https://github.com/headius/thread_safe
 licenses:
 - Apache-2.0
@@ -116,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.1.9
+rubygems_version: 2.2.2
 signing_key:
 specification_version: 4
 summary: A collection of data structures and utilities to make thread-safe programming in Ruby easier