thread_safe 0.3.4-java → 0.3.5-java

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 34a5cc5ef3dfed9a31da69198a6aec9590070c05
-  data.tar.gz: 84f4f94772109373b2fcfc72f3f7bebb4bf8d13c
+  metadata.gz: fbd202dbf911be29e025cf656ec85fa07024805f
+  data.tar.gz: ece8fcb51b53bea677a7de3bd3729b5a2345e394
 SHA512:
-  metadata.gz: 12c0a59e4960fc7e913b12be6e4d05fc0be65f73eb18ed7caf06f99e76dacc306a68b90a1c1ff648fca1057f1c960d9d76048e052b7a416309e9176f8546ab25
-  data.tar.gz: 47a278848d8ef4783b8382b7de1fa433f9e33fc3b2d3215180ffdd34ac482ec31d28dd2ad755cb124b77e14b2d885c8074257fdb74f814845c69f88d87314a77
+  metadata.gz: 8262d11575eda01b362dcf1661cfb023e1a6216fdffdfb0e4a47d4f48d0ea87a6d3950af9978d23dd9d85d524bbeef72f8b13b5c12db0bd930886bff2806c0d6
+  data.tar.gz: b1ac9f0689d82854d827dc58009e519518cb57cc25bb3908465322739b9e3f92c6d51e43e5f54fb89dc30ac6efa4136e5884fa6aecabf0b3eb8801fffb283aed

data/.travis.yml

@@ -1,24 +1,43 @@
 language: ruby
 rvm:
-  - jruby-18mode
-  - jruby-19mode
-  - rbx-2
-  - 1.8.7
-  - 1.9.3
+  - 2.2.0
+  - 2.1.5
+  - 2.1.4
   - 2.0.0
-  - 2.1.0
+  - 1.9.3
+  - ruby-head
+  - jruby-1.7.18
+  - jruby-head
+  - rbx-2
 jdk: # for JRuby only
   - openjdk7
   - oraclejdk8
 matrix:
   exclude:
-    - rvm: rbx-2
+    - rvm: 2.2.0
+      jdk: openjdk7
       jdk: oraclejdk8
-    - rvm: 1.8.7
+    - rvm: 2.1.5
+      jdk: openjdk7
       jdk: oraclejdk8
-    - rvm: 1.9.3
+    - rvm: 2.1.4
+      jdk: openjdk7
       jdk: oraclejdk8
     - rvm: 2.0.0
+      jdk: openjdk7
       jdk: oraclejdk8
-    - rvm: 2.1.0
-      jdk: oraclejdk8
+    - rvm: 1.9.3
+      jdk: openjdk7
+      jdk: oraclejdk8
+    - rvm: ruby-head
+      jdk: openjdk7
+      jdk: oraclejdk8
+    - rvm: rbx-2
+      jdk: openjdk7
+      jdk: oraclejdk8
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: 1.9.3
+
+script: "rake TESTOPTS='--seed=1'"

data/.yardopts

@@ -0,0 +1,13 @@
+--protected
+--no-private
+--embed-mixins
+--output-dir ./yardoc
+--markup markdown
+--title=Concurrent Ruby
+--template default
+--template-path ./yard-template
+
+./lib/**/*.rb
+-
+README.md
+LICENSE

data/Gemfile

@@ -1,4 +1,17 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in thread_safe.gemspec
 gemspec
+
+group :development, :test do
+  gem 'minitest', '~> 5.5.1'
+  gem 'minitest-reporters', '~> 1.0.11'
+  gem 'simplecov', '~> 0.9.2', :require => false
+  gem 'coveralls', '~> 0.7.11', :require => false
+end
+
+group :documentation do
+  gem 'countloc', '~> 0.4.0', :platforms => :mri, :require => false
+  gem 'yard', '~> 0.8.7.6', :require => false
+  gem 'inch', '~> 0.5.10', :platforms => :mri, :require => false
+  gem 'redcarpet', '~> 3.2.2', platforms: :mri # understands github markdown
+end

data/README.md

@@ -1,6 +1,6 @@
 # Threadsafe
 
-[![Build Status](https://travis-ci.org/headius/thread_safe.png)](https://travis-ci.org/headius/thread_safe)
+[![Gem Version](https://badge.fury.io/rb/thread_safe.svg)](http://badge.fury.io/rb/thread_safe) [![Build Status](https://travis-ci.org/ruby-concurrency/thread_safe.svg?branch=master)](https://travis-ci.org/ruby-concurrency/thread_safe) [![Coverage Status](https://img.shields.io/coveralls/ruby-concurrency/thread_safe/master.svg)](https://coveralls.io/r/ruby-concurrency/thread_safe) [![Code Climate](https://codeclimate.com/github/ruby-concurrency/thread_safe.svg)](https://codeclimate.com/github/ruby-concurrency/thread_safe) [![Dependency Status](https://gemnasium.com/ruby-concurrency/thread_safe.svg)](https://gemnasium.com/ruby-concurrency/thread_safe) [![License](https://img.shields.io/badge/license-apache-green.svg)](http://opensource.org/licenses/MIT) [![Gitter chat](http://img.shields.io/badge/gitter-join%20chat%20%E2%86%92-brightgreen.svg)](https://gitter.im/ruby-concurrency/concurrent-ruby)
 
 A collection of thread-safe versions of common core Ruby classes.
 

data/Rakefile

@@ -1,6 +1,19 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+## safely load all the rake tasks in the `tasks` directory
+def safe_load(file)
+  begin
+    load file
+  rescue LoadError => ex
+    puts "Error loading rake tasks from '#{file}' but will continue..."
+    puts ex.message
+  end
+end
+Dir.glob('tasks/**/*.rake').each do |rakefile|
+  safe_load rakefile
+end
+
 task :default => :test
 
 if defined?(JRUBY_VERSION)
@@ -36,7 +49,7 @@ if defined?(JRUBY_VERSION)
     ant.jar :basedir => 'pkg/tests', :destfile => 'test/package.jar', :includes => '**/*.class'
   end
 
-  task :package => [ :jar, 'test-jar' ]
+  task :package => [ :clean, :compile, :jar, 'test-jar' ]
 else
   # No need to package anything for non-jruby rubies
   task :package

data/ext/org/jruby/ext/thread_safe/JRubyCacheBackendLibrary.java

@@ -63,7 +63,7 @@ public class JRubyCacheBackendLibrary implements Library {
                 return true;
             } catch (Throwable t) { // ensuring we really do catch everything
                 // Doug's Unsafe setup errors always have this "Could not ini.." message
-                if (t.getMessage().contains("Could not initialize intrinsics") || isCausedBySecurityException(t)) {
+                if (isCausedBySecurityException(t)) {
                     return false;
                 }
                 throw (t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(t));
@@ -72,7 +72,7 @@ public class JRubyCacheBackendLibrary implements Library {
 
         private static boolean isCausedBySecurityException(Throwable t) {
             while (t != null) {
-                if (t instanceof SecurityException) {
+                if ((t.getMessage() != null && t.getMessage().contains("Could not initialize intrinsics")) || t instanceof SecurityException) {
                     return true;
                 }
                 t = t.getCause();

data/lib/thread_safe/atomic_reference_cache_backend.rb

@@ -1,169 +1,158 @@
 module ThreadSafe
-  # A Ruby port of the Doug Lea's jsr166e.ConcurrentHashMapV8 class version 1.59 available in public domain.
-  # Original source code available here: http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/ConcurrentHashMapV8.java?revision=1.59
+  # A Ruby port of the Doug Lea's jsr166e.ConcurrentHashMapV8 class version 1.59
+  # available in public domain.
   #
-  # The Ruby port skips out the +TreeBin+ (red-black trees for use in bins
-  # whose size exceeds a threshold).
+  # Original source code available here:
+  # http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/ConcurrentHashMapV8.java?revision=1.59
   #
-  # A hash table supporting full concurrency of retrievals and
-  # high expected concurrency for updates. However, even though all
-  # operations are thread-safe, retrieval operations do _not_ entail locking,
-  # and there is _not_ any support for locking the entire table
-  # in a way that prevents all access.
+  # The Ruby port skips out the +TreeBin+ (red-black trees for use in bins whose
+  # size exceeds a threshold).
   #
-  # Retrieval operations generally do not block, so may overlap with
-  # update operations. Retrievals reflect the results of the most
-  # recently _completed_ update operations holding upon their
-  # onset. (More formally, an update operation for a given key bears a
-  # _happens-before_ relation with any (non +nil+) retrieval for
-  # that key reporting the updated value.)  For aggregate operations
-  # such as +clear()+, concurrent retrievals may reflect insertion or removal
-  # of only some entries.  Similarly, the +each_pair+ iterator yields elements
-  # reflecting the state of the hash table at some point at or since
-  # the start of the +each_pair+. Bear in mind that the results of
-  # aggregate status methods including +size()+ and +empty?+} are typically
-  # useful only when a map is not undergoing concurrent updates in other
-  # threads. Otherwise the results of these methods reflect transient
-  # states that may be adequate for monitoring or estimation purposes, but not
-  # for program control.
+  # A hash table supporting full concurrency of retrievals and high expected
+  # concurrency for updates. However, even though all operations are
+  # thread-safe, retrieval operations do _not_ entail locking, and there is
+  # _not_ any support for locking the entire table in a way that prevents all
+  # access.
   #
-  # The table is dynamically expanded when there are too many
-  # collisions (i.e., keys that have distinct hash codes but fall into
-  # the same slot modulo the table size), with the expected average
-  # effect of maintaining roughly two bins per mapping (corresponding
-  # to a 0.75 load factor threshold for resizing). There may be much
-  # variance around this average as mappings are added and removed, but
-  # overall, this maintains a commonly accepted time/space tradeoff for
-  # hash tables.  However, resizing this or any other kind of hash
-  # table may be a relatively slow operation. When possible, it is a
-  # good idea to provide a size estimate as an optional :initial_capacity
+  # Retrieval operations generally do not block, so may overlap with update
+  # operations. Retrievals reflect the results of the most recently _completed_
+  # update operations holding upon their onset. (More formally, an update
+  # operation for a given key bears a _happens-before_ relation with any (non
+  # +nil+) retrieval for that key reporting the updated value.) For aggregate
+  # operations such as +clear()+, concurrent retrievals may reflect insertion or
+  # removal of only some entries. Similarly, the +each_pair+ iterator yields
+  # elements reflecting the state of the hash table at some point at or since
+  # the start of the +each_pair+. Bear in mind that the results of aggregate
+  # status methods including +size()+ and +empty?+} are typically useful only
+  # when a map is not undergoing concurrent updates in other threads. Otherwise
+  # the results of these methods reflect transient states that may be adequate
+  # for monitoring or estimation purposes, but not for program control.
+  #
+  # The table is dynamically expanded when there are too many collisions (i.e.,
+  # keys that have distinct hash codes but fall into the same slot modulo the
+  # table size), with the expected average effect of maintaining roughly two
+  # bins per mapping (corresponding to a 0.75 load factor threshold for
+  # resizing). There may be much variance around this average as mappings are
+  # added and removed, but overall, this maintains a commonly accepted
+  # time/space tradeoff for hash tables. However, resizing this or any other
+  # kind of hash table may be a relatively slow operation. When possible, it is
+  # a good idea to provide a size estimate as an optional :initial_capacity
   # initializer argument. An additional optional :load_factor constructor
-  # argument provides a further means of customizing initial table capacity
-  # by specifying the table density to be used in calculating the amount of
-  # space to allocate for the given number of elements. Note that using
-  # many keys with exactly the same +hash+ is a sure way to slow down
-  # performance of any hash table.
+  # argument provides a further means of customizing initial table capacity by
+  # specifying the table density to be used in calculating the amount of space
+  # to allocate for the given number of elements. Note that using many keys with
+  # exactly the same +hash+ is a sure way to slow down performance of any hash
+  # table.
   #
-  # == Design overview
+  # ## Design overview
   #
-  # The primary design goal of this hash table is to maintain
-  # concurrent readability (typically method +[]+, but also
-  # iteration and related methods) while minimizing update
-  # contention. Secondary goals are to keep space consumption about
-  # the same or better than plain +Hash+, and to support high
+  # The primary design goal of this hash table is to maintain concurrent
+  # readability (typically method +[]+, but also iteration and related methods)
+  # while minimizing update contention. Secondary goals are to keep space
+  # consumption about the same or better than plain +Hash+, and to support high
   # initial insertion rates on an empty table by many threads.
   #
-  # Each key-value mapping is held in a +Node+. The validation-based
-  # approach explained below leads to a lot of code sprawl because
-  # retry-control precludes factoring into smaller methods.
+  # Each key-value mapping is held in a +Node+. The validation-based approach
+  # explained below leads to a lot of code sprawl because retry-control
+  # precludes factoring into smaller methods.
+  #
+  # The table is lazily initialized to a power-of-two size upon the first
+  # insertion. Each bin in the table normally contains a list of +Node+s (most
+  # often, the list has only zero or one +Node+). Table accesses require
+  # volatile/atomic reads, writes, and CASes. The lists of nodes within bins are
+  # always accurately traversable under volatile reads, so long as lookups check
+  # hash code and non-nullness of value before checking key equality.
   #
-  # The table is lazily initialized to a power-of-two size upon the
-  # first insertion.  Each bin in the table normally contains a
-  # list of +Node+s (most often, the list has only zero or one +Node+).
-  # Table accesses require volatile/atomic reads, writes, and
-  # CASes. The lists of nodes within bins are always accurately traversable
-  # under volatile reads, so long as lookups check hash code
-  # and non-nullness of value before checking key equality.
+  # We use the top two bits of +Node+ hash fields for control purposes -- they
+  # are available anyway because of addressing constraints. As explained further
+  # below, these top bits are used as follows:
   #
-  # We use the top two bits of +Node+ hash fields for control
-  # purposes -- they are available anyway because of addressing
-  # constraints.  As explained further below, these top bits are
-  # used as follows:
-  #  00 - Normal
-  #  01 - Locked
-  #  11 - Locked and may have a thread waiting for lock
-  #  10 - +Node+ is a forwarding node
+  #   - 00 - Normal
+  #   - 01 - Locked
+  #   - 11 - Locked and may have a thread waiting for lock
+  #   - 10 - +Node+ is a forwarding node
   #
-  # The lower 28 bits of each +Node+'s hash field contain a
-  # the key's hash code, except for forwarding nodes, for which
-  # the lower bits are zero (and so always have hash field == +MOVED+).
+  # The lower 28 bits of each +Node+'s hash field contain a the key's hash code,
+  # except for forwarding nodes, for which the lower bits are zero (and so
+  # always have hash field == +MOVED+).
   #
-  # Insertion (via +[]=+ or its variants) of the first node in an
-  # empty bin is performed by just CASing it to the bin.  This is
-  # by far the most common case for put operations under most
-  # key/hash distributions.  Other update operations (insert,
-  # delete, and replace) require locks.  We do not want to waste
-  # the space required to associate a distinct lock object with
-  # each bin, so instead use the first node of a bin list itself as
-  # a lock. Blocking support for these locks relies +Util::CheapLockable.
-  # However, we also need a +try_lock+ construction, so we overlay
-  # these by using bits of the +Node+ hash field for lock control (see above),
-  # and so normally use builtin monitors only for blocking and signalling using
+  # Insertion (via +[]=+ or its variants) of the first node in an empty bin is
+  # performed by just CASing it to the bin. This is by far the most common case
+  # for put operations under most key/hash distributions. Other update
+  # operations (insert, delete, and replace) require locks. We do not want to
+  # waste the space required to associate a distinct lock object with each bin,
+  # so instead use the first node of a bin list itself as a lock. Blocking
+  # support for these locks relies +Util::CheapLockable. However, we also need a
+  # +try_lock+ construction, so we overlay these by using bits of the +Node+
+  # hash field for lock control (see above), and so normally use builtin
+  # monitors only for blocking and signalling using
   # +cheap_wait+/+cheap_broadcast+ constructions. See +Node#try_await_lock+.
   #
-  # Using the first node of a list as a lock does not by itself
-  # suffice though: When a node is locked, any update must first
-  # validate that it is still the first node after locking it, and
-  # retry if not. Because new nodes are always appended to lists,
-  # once a node is first in a bin, it remains first until deleted
-  # or the bin becomes invalidated (upon resizing).  However,
-  # operations that only conditionally update may inspect nodes
-  # until the point of update. This is a converse of sorts to the
-  # lazy locking technique described by Herlihy & Shavit.
+  # Using the first node of a list as a lock does not by itself suffice though:
+  # When a node is locked, any update must first validate that it is still the
+  # first node after locking it, and retry if not. Because new nodes are always
+  # appended to lists, once a node is first in a bin, it remains first until
+  # deleted or the bin becomes invalidated (upon resizing). However, operations
+  # that only conditionally update may inspect nodes until the point of update.
+  # This is a converse of sorts to the lazy locking technique described by
+  # Herlihy & Shavit.
   #
-  # The main disadvantage of per-bin locks is that other update
-  # operations on other nodes in a bin list protected by the same
-  # lock can stall, for example when user +eql?+ or mapping
-  # functions take a long time.  However, statistically, under
-  # random hash codes, this is not a common problem.  Ideally, the
-  # frequency of nodes in bins follows a Poisson distribution
-  # (http://en.wikipedia.org/wiki/Poisson_distribution) with a
-  # parameter of about 0.5 on average, given the resizing threshold
-  # of 0.75, although with a large variance because of resizing
-  # granularity. Ignoring variance, the expected occurrences of
-  # list size k are (exp(-0.5) * pow(0.5, k) / factorial(k)). The
-  # first values are:
+  # The main disadvantage of per-bin locks is that other update operations on
+  # other nodes in a bin list protected by the same lock can stall, for example
+  # when user +eql?+ or mapping functions take a long time. However,
+  # statistically, under random hash codes, this is not a common problem.
+  # Ideally, the frequency of nodes in bins follows a Poisson distribution
+  # (http://en.wikipedia.org/wiki/Poisson_distribution) with a parameter of
+  # about 0.5 on average, given the resizing threshold of 0.75, although with a
+  # large variance because of resizing granularity. Ignoring variance, the
+  # expected occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
+  # factorial(k)). The first values are:
   #
-  #  0:    0.60653066
-  #  1:    0.30326533
-  #  2:    0.07581633
-  #  3:    0.01263606
-  #  4:    0.00157952
-  #  5:    0.00015795
-  #  6:    0.00001316
-  #  7:    0.00000094
-  #  8:    0.00000006
-  #  more: less than 1 in ten million
+  #   - 0:    0.60653066
+  #   - 1:    0.30326533
+  #   - 2:    0.07581633
+  #   - 3:    0.01263606
+  #   - 4:    0.00157952
+  #   - 5:    0.00015795
+  #   - 6:    0.00001316
+  #   - 7:    0.00000094
+  #   - 8:    0.00000006
+  #   - more: less than 1 in ten million
   #
-  # Lock contention probability for two threads accessing distinct
-  # elements is roughly 1 / (8 * #elements) under random hashes.
+  # Lock contention probability for two threads accessing distinct elements is
+  # roughly 1 / (8 * #elements) under random hashes.
   #
-  # The table is resized when occupancy exceeds a percentage
-  # threshold (nominally, 0.75, but see below).  Only a single
-  # thread performs the resize (using field +size_control+, to arrange
-  # exclusion), but the table otherwise remains usable for reads
-  # and updates. Resizing proceeds by transferring bins, one by
-  # one, from the table to the next table.  Because we are using
-  # power-of-two expansion, the elements from each bin must either
-  # stay at same index, or move with a power of two offset. We
-  # eliminate unnecessary node creation by catching cases where old
-  # nodes can be reused because their next fields won't change.  On
-  # average, only about one-sixth of them need cloning when a table
-  # doubles. The nodes they replace will be garbage collectable as
-  # soon as they are no longer referenced by any reader thread that
-  # may be in the midst of concurrently traversing table.  Upon
-  # transfer, the old table bin contains only a special forwarding
-  # node (with hash field +MOVED+) that contains the next table as
-  # its key. On encountering a forwarding node, access and update
-  # operations restart, using the new table.
+  # The table is resized when occupancy exceeds a percentage threshold
+  # (nominally, 0.75, but see below). Only a single thread performs the resize
+  # (using field +size_control+, to arrange exclusion), but the table otherwise
+  # remains usable for reads and updates. Resizing proceeds by transferring
+  # bins, one by one, from the table to the next table. Because we are using
+  # power-of-two expansion, the elements from each bin must either stay at same
+  # index, or move with a power of two offset. We eliminate unnecessary node
+  # creation by catching cases where old nodes can be reused because their next
+  # fields won't change. On average, only about one-sixth of them need cloning
+  # when a table doubles. The nodes they replace will be garbage collectable as
+  # soon as they are no longer referenced by any reader thread that may be in
+  # the midst of concurrently traversing table. Upon transfer, the old table bin
+  # contains only a special forwarding node (with hash field +MOVED+) that
+  # contains the next table as its key. On encountering a forwarding node,
+  # access and update operations restart, using the new table.
   #
-  # Each bin transfer requires its bin lock. However, unlike other
-  # cases, a transfer can skip a bin if it fails to acquire its
-  # lock, and revisit it later. Method +rebuild+ maintains a buffer of
-  # TRANSFER_BUFFER_SIZE bins that have been skipped because of failure
-  # to acquire a lock, and blocks only if none are available
-  # (i.e., only very rarely). The transfer operation must also ensure
-  # that all accessible bins in both the old and new table are usable by
-  # any traversal. When there are no lock acquisition failures, this is
-  # arranged simply by proceeding from the last bin (+table.size - 1+) up
-  # towards the first.  Upon seeing a forwarding node, traversals arrange
-  # to move to the new table without revisiting nodes. However, when any
-  # node is skipped during a transfer, all earlier table bins may have
-  # become visible, so are initialized with a reverse-forwarding node back
-  # to the old table until the new ones are established. (This
-  # sometimes requires transiently locking a forwarding node, which
-  # is possible under the above encoding.) These more expensive
-  # mechanics trigger only when necessary.
+  # Each bin transfer requires its bin lock. However, unlike other cases, a
+  # transfer can skip a bin if it fails to acquire its lock, and revisit it
+  # later. Method +rebuild+ maintains a buffer of TRANSFER_BUFFER_SIZE bins that
+  # have been skipped because of failure to acquire a lock, and blocks only if
+  # none are available (i.e., only very rarely). The transfer operation must
+  # also ensure that all accessible bins in both the old and new table are
+  # usable by any traversal. When there are no lock acquisition failures, this
+  # is arranged simply by proceeding from the last bin (+table.size - 1+) up
+  # towards the first. Upon seeing a forwarding node, traversals arrange to move
+  # to the new table without revisiting nodes. However, when any node is skipped
+  # during a transfer, all earlier table bins may have become visible, so are
+  # initialized with a reverse-forwarding node back to the old table until the
+  # new ones are established. (This sometimes requires transiently locking a
+  # forwarding node, which is possible under the above encoding.) These more
+  # expensive mechanics trigger only when necessary.
   #
   # The traversal scheme also applies to partial traversals of
   # ranges of bins (via an alternate Traverser constructor)
@@ -229,10 +218,10 @@ module ThreadSafe
       end
     end
 
-    # Key-value entry. Nodes with a hash field of +MOVED+ are special,
-    # and do not contain user keys or values.  Otherwise, keys are never +nil+,
-    # and +NULL+ +value+ fields indicate that a node is in the process
-    # of being deleted or created. For purposes of read-only access, a key may be read
+    # Key-value entry. Nodes with a hash field of +MOVED+ are special, and do
+    # not contain user keys or values. Otherwise, keys are never +nil+, and
+    # +NULL+ +value+ fields indicate that a node is in the process of being
+    # deleted or created. For purposes of read-only access, a key may be read
     # before a value, but can only be used after checking value to be +!= NULL+.
     class Node
       extend Util::Volatile
@@ -259,17 +248,15 @@ module ThreadSafe
         self.next = next_node
       end
 
-      # Spins a while if +LOCKED+ bit set and this node is the first
-      # of its bin, and then sets +WAITING+ bits on hash field and
-      # blocks (once) if they are still set.  It is OK for this
-      # method to return even if lock is not available upon exit,
-      # which enables these simple single-wait mechanics.
+      # Spins a while if +LOCKED+ bit set and this node is the first of its bin,
+      # and then sets +WAITING+ bits on hash field and blocks (once) if they are
+      # still set. It is OK for this method to return even if lock is not
+      # available upon exit, which enables these simple single-wait mechanics.
       #
-      # The corresponding signalling operation is performed within
-      # callers: Upon detecting that +WAITING+ has been set when
-      # unlocking lock (via a failed CAS from non-waiting +LOCKED+
-      # state), unlockers acquire the +cheap_synchronize+ lock and
-      # perform a +cheap_broadcast+.
+      # The corresponding signalling operation is performed within callers: Upon
+      # detecting that +WAITING+ has been set when unlocking lock (via a failed
+      # CAS from non-waiting +LOCKED+ state), unlockers acquire the
+      # +cheap_synchronize+ lock and perform a +cheap_broadcast+.
       def try_await_lock(table, i)
         if table && i >= 0 && i < table.size # bounds check, TODO: why are we bounds checking?
           spins = SPIN_LOCK_ATTEMPTS
@@ -360,12 +347,12 @@ module ThreadSafe
     extend Util::Volatile
     attr_volatile :table, # The array of bins. Lazily initialized upon first insertion. Size is always a power of two.
 
-                  # Table initialization and resizing control.  When negative, the
-                  # table is being initialized or resized. Otherwise, when table is
-                  # null, holds the initial table size to use upon creation, or 0
-                  # for default. After initialization, holds the next element count
-                  # value upon which to resize the table.
-                  :size_control
+    # Table initialization and resizing control.  When negative, the
+    # table is being initialized or resized. Otherwise, when table is
+    # null, holds the initial table size to use upon creation, or 0
+    # for default. After initialization, holds the next element count
+    # value upon which to resize the table.
+    :size_control
 
     def initialize(options = nil)
       super()
@@ -786,10 +773,9 @@ module ThreadSafe
       current_table
     end
 
-    # If table is too small and not already resizing, creates next
-    # table and transfers bins.  Rechecks occupancy after a transfer
-    # to see if another resize is already needed because resizings
-    # are lagging additions.
+    # If table is too small and not already resizing, creates next table and
+    # transfers bins. Rechecks occupancy after a transfer to see if another
+    # resize is already needed because resizings are lagging additions.
     def check_for_resize
       while (current_table = table) && MAX_CAPACITY > (table_size = current_table.size) && NOW_RESIZING != (size_ctrl = size_control) && size_ctrl < @counter.sum
         try_in_resize_lock(current_table, size_ctrl) do

data/lib/thread_safe/mri_cache_backend.rb

@@ -1,14 +1,21 @@
 module ThreadSafe
   class MriCacheBackend < NonConcurrentCacheBackend
-    # We can get away with a single global write lock (instead of a per-instance one) because of the GVL/green threads.
+    # We can get away with a single global write lock (instead of a per-instance
+    # one) because of the GVL/green threads.
     #
-    # The previous implementation used `Thread.critical` on 1.8 MRI to implement the 4 composed atomic operations (`put_if_absent`, `replace_pair`,
-    # `replace_if_exists`, `delete_pair`) this however doesn't work for `compute_if_absent` because on 1.8 the Mutex class is itself implemented
-    # via `Thread.critical` and a call to `Mutex#lock` does not restore the previous `Thread.critical` value (thus any synchronisation clears the
-    # `Thread.critical` flag and we loose control). This poses a problem as the provided block might use synchronisation on its own.
+    # The previous implementation used `Thread.critical` on 1.8 MRI to implement
+    # the 4 composed atomic operations (`put_if_absent`, `replace_pair`,
+    # `replace_if_exists`, `delete_pair`) this however doesn't work for
+    # `compute_if_absent` because on 1.8 the Mutex class is itself implemented
+    # via `Thread.critical` and a call to `Mutex#lock` does not restore the
+    # previous `Thread.critical` value (thus any synchronisation clears the
+    # `Thread.critical` flag and we loose control). This poses a problem as the
+    # provided block might use synchronisation on its own.
     #
-    # NOTE: a neat idea of writing a c-ext to manually perform atomic put_if_absent, while relying on Ruby not releasing a GVL while calling
-    # a c-ext will not work because of the potentially Ruby implemented `#hash` and `#eql?` key methods.
+    # NOTE: a neat idea of writing a c-ext to manually perform atomic
+    # put_if_absent, while relying on Ruby not releasing a GVL while calling a
+    # c-ext will not work because of the potentially Ruby implemented `#hash`
+    # and `#eql?` key methods.
     WRITE_LOCK = Mutex.new
 
     def []=(key, value)

data/lib/thread_safe/non_concurrent_cache_backend.rb

@@ -1,7 +1,9 @@
 module ThreadSafe
   class NonConcurrentCacheBackend
-    # WARNING: all public methods of the class must operate on the @backend directly without calling each other. This is important
-    # because of the SynchronizedCacheBackend which uses a non-reentrant mutex for perfomance reasons.
+    # WARNING: all public methods of the class must operate on the @backend
+    # directly without calling each other. This is important because of the
+    # SynchronizedCacheBackend which uses a non-reentrant mutex for perfomance
+    # reasons.
     def initialize(options = nil)
       @backend = {}
     end

data/lib/thread_safe/synchronized_cache_backend.rb

@@ -2,7 +2,8 @@ module ThreadSafe
   class SynchronizedCacheBackend < NonConcurrentCacheBackend
     require 'mutex_m'
     include Mutex_m
-    # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are not allowed to call each other.
+    # WARNING: Mutex_m is a non-reentrant lock, so the synchronized methods are
+    # not allowed to call each other.
 
     def [](key)
       synchronize { super }

data/lib/thread_safe/synchronized_delegator.rb

@@ -9,9 +9,9 @@ require 'monitor'
 #   array = SynchronizedDelegator.new([]) # thread-safe
 #
 # A simple `Monitor` provides a very coarse-grained way to synchronize a given
-# object, in that it will cause synchronization for methods that have no
-# need for it, but this is a trivial way to get thread-safety where none may
-# exist currently on some implementations.
+# object, in that it will cause synchronization for methods that have no need
+# for it, but this is a trivial way to get thread-safety where none may exist
+# currently on some implementations.
 #
 # This class is currently being considered for inclusion into stdlib, via
 # https://bugs.ruby-lang.org/issues/8556

data/lib/thread_safe/util/adder.rb

@@ -1,7 +1,10 @@
 module ThreadSafe
   module Util
-    # A Ruby port of the Doug Lea's jsr166e.LondAdder class version 1.8 available in public domain.
-    # Original source code available here: http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/LongAdder.java?revision=1.8
+    # A Ruby port of the Doug Lea's jsr166e.LondAdder class version 1.8
+    # available in public domain.
+    #
+    # Original source code available here:
+    # http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/LongAdder.java?revision=1.8
     #
     # One or more variables that together maintain an initially zero
     # sum. When updates (method +add+) are contended across threads,

data/lib/thread_safe/util/cheap_lockable.rb

@@ -1,6 +1,7 @@
 module ThreadSafe
   module Util
-    # Provides a cheapest possible (mainly in terms of memory usage) +Mutex+ with the +ConditionVariable+ bundled in.
+    # Provides a cheapest possible (mainly in terms of memory usage) +Mutex+
+    # with the +ConditionVariable+ bundled in.
     #
     # Usage:
     #   class A

data/lib/thread_safe/util/striped64.rb

@@ -1,69 +1,65 @@
 module ThreadSafe
   module Util
-    # A Ruby port of the Doug Lea's jsr166e.Striped64 class version 1.6 available in public domain.
-    # Original source code available here: http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/Striped64.java?revision=1.6
+    # A Ruby port of the Doug Lea's jsr166e.Striped64 class version 1.6
+    # available in public domain.
     #
-    # Class holding common representation and mechanics for classes supporting dynamic striping on 64bit values.
+    # Original source code available here:
+    # http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/Striped64.java?revision=1.6
     #
-    # This class maintains a lazily-initialized table of atomically
-    # updated variables, plus an extra +base+ field. The table size
-    # is a power of two. Indexing uses masked per-thread hash codes.
-    # Nearly all methods on this class are private, accessed directly
-    # by subclasses.
+    # Class holding common representation and mechanics for classes supporting
+    # dynamic striping on 64bit values.
     #
-    # Table entries are of class +Cell+; a variant of AtomicLong padded
-    # to reduce cache contention on most processors. Padding is
-    # overkill for most Atomics because they are usually irregularly
-    # scattered in memory and thus don't interfere much with each
-    # other. But Atomic objects residing in arrays will tend to be
-    # placed adjacent to each other, and so will most often share
-    # cache lines (with a huge negative performance impact) without
+    # This class maintains a lazily-initialized table of atomically updated
+    # variables, plus an extra +base+ field. The table size is a power of two.
+    # Indexing uses masked per-thread hash codes. Nearly all methods on this
+    # class are private, accessed directly by subclasses.
+    #
+    # Table entries are of class +Cell+; a variant of AtomicLong padded to
+    # reduce cache contention on most processors. Padding is overkill for most
+    # Atomics because they are usually irregularly scattered in memory and thus
+    # don't interfere much with each other. But Atomic objects residing in
+    # arrays will tend to be placed adjacent to each other, and so will most
+    # often share cache lines (with a huge negative performance impact) without
     # this precaution.
     #
-    # In part because +Cell+s are relatively large, we avoid creating
-    # them until they are needed.  When there is no contention, all
-    # updates are made to the +base+ field.  Upon first contention (a
-    # failed CAS on +base+ update), the table is initialized to size 2.
-    # The table size is doubled upon further contention until
-    # reaching the nearest power of two greater than or equal to the
-    # number of CPUS. Table slots remain empty (+nil+) until they are
+    # In part because +Cell+s are relatively large, we avoid creating them until
+    # they are needed. When there is no contention, all updates are made to the
+    # +base+ field. Upon first contention (a failed CAS on +base+ update), the
+    # table is initialized to size 2. The table size is doubled upon further
+    # contention until reaching the nearest power of two greater than or equal
+    # to the number of CPUS. Table slots remain empty (+nil+) until they are
     # needed.
     #
-    # A single spinlock (+busy+) is used for initializing and
-    # resizing the table, as well as populating slots with new +Cell+s.
-    # There is no need for a blocking lock: When the lock is not
-    # available, threads try other slots (or the base).  During these
-    # retries, there is increased contention and reduced locality,
-    # which is still better than alternatives.
+    # A single spinlock (+busy+) is used for initializing and resizing the
+    # table, as well as populating slots with new +Cell+s. There is no need for
+    # a blocking lock: When the lock is not available, threads try other slots
+    # (or the base). During these retries, there is increased contention and
+    # reduced locality, which is still better than alternatives.
     #
-    # Per-thread hash codes are initialized to random values.
-    # Contention and/or table collisions are indicated by failed
-    # CASes when performing an update operation (see method
-    # +retry_update+). Upon a collision, if the table size is less than
-    # the capacity, it is doubled in size unless some other thread
-    # holds the lock. If a hashed slot is empty, and lock is
-    # available, a new +Cell+ is created. Otherwise, if the slot
-    # exists, a CAS is tried.  Retries proceed by "double hashing",
-    # using a secondary hash (XorShift) to try to find a
-    # free slot.
+    # Per-thread hash codes are initialized to random values. Contention and/or
+    # table collisions are indicated by failed CASes when performing an update
+    # operation (see method +retry_update+). Upon a collision, if the table size
+    # is less than the capacity, it is doubled in size unless some other thread
+    # holds the lock. If a hashed slot is empty, and lock is available, a new
+    # +Cell+ is created. Otherwise, if the slot exists, a CAS is tried. Retries
+    # proceed by "double hashing", using a secondary hash (XorShift) to try to
+    # find a free slot.
     #
-    # The table size is capped because, when there are more threads
-    # than CPUs, supposing that each thread were bound to a CPU,
-    # there would exist a perfect hash function mapping threads to
-    # slots that eliminates collisions. When we reach capacity, we
-    # search for this mapping by randomly varying the hash codes of
-    # colliding threads.  Because search is random, and collisions
-    # only become known via CAS failures, convergence can be slow,
-    # and because threads are typically not bound to CPUS forever,
-    # may not occur at all. However, despite these limitations,
-    # observed contention rates are typically low in these cases.
+    # The table size is capped because, when there are more threads than CPUs,
+    # supposing that each thread were bound to a CPU, there would exist a
+    # perfect hash function mapping threads to slots that eliminates collisions.
+    # When we reach capacity, we search for this mapping by randomly varying the
+    # hash codes of colliding threads. Because search is random, and collisions
+    # only become known via CAS failures, convergence can be slow, and because
+    # threads are typically not bound to CPUS forever, may not occur at all.
+    # However, despite these limitations, observed contention rates are
+    # typically low in these cases.
     #
-    # It is possible for a +Cell+ to become unused when threads that
-    # once hashed to it terminate, as well as in the case where
-    # doubling the table causes no thread to hash to it under
-    # expanded mask.  We do not try to detect or remove such cells,
-    # under the assumption that for long-running instances, observed
-    # contention levels will recur, so the cells will eventually be
+    # It is possible for a +Cell+ to become unused when threads that once hashed
+    # to it terminate, as well as in the case where doubling the table causes no
+    # thread to hash to it under expanded mask. We do not try to detect or
+    # remove such cells, under the assumption that for long-running instances,
+    # observed contention levels will recur, so the cells will eventually be
     # needed again; and for short-lived ones, it does not matter.
     class Striped64
       # Padded variant of AtomicLong supporting only raw accesses plus CAS.
@@ -85,8 +81,8 @@ module ThreadSafe
 
       extend Volatile
       attr_volatile :cells, # Table of cells. When non-null, size is a power of 2.
-                    :base,  # Base value, used mainly when there is no contention, but also as a fallback during table initialization races. Updated via CAS.
-                    :busy   # Spinlock (locked via CAS) used when resizing and/or creating Cells.
+      :base,  # Base value, used mainly when there is no contention, but also as a fallback during table initialization races. Updated via CAS.
+      :busy   # Spinlock (locked via CAS) used when resizing and/or creating Cells.
 
       alias_method :busy?, :busy
 

data/lib/thread_safe/util/volatile.rb

@@ -1,7 +1,9 @@
 module ThreadSafe
   module Util
     module Volatile
-      # Provides +volatile+ (in the JVM's sense) attribute accessors implemented atop of the +AtomicReference+s.
+      # Provides +volatile+ (in the JVM's sense) attribute accessors implemented
+      # atop of the +AtomicReference+s.
+      #
       # Usage:
       #   class Foo
       #     extend ThreadSafe::Util::Volatile

data/lib/thread_safe/util/xor_shift_random.rb

@@ -1,7 +1,9 @@
 module ThreadSafe
   module Util
-    # A xorshift random number (positive +Fixnum+s) generator, provides reasonably cheap way to generate thread local random numbers without contending for
-    # the global +Kernel.rand+.
+    # A xorshift random number (positive +Fixnum+s) generator, provides
+    # reasonably cheap way to generate thread local random numbers without
+    # contending for the global +Kernel.rand+.
+    #
     # Usage:
     #   x = XorShiftRandom.get # uses Kernel.rand to generate an initial seed
     #   while true

data/lib/thread_safe/version.rb

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

data/tasks/update_doc.rake

@@ -0,0 +1,45 @@
+require 'yard'
+YARD::Rake::YardocTask.new
+
+root = File.expand_path File.join(File.dirname(__FILE__), '..')
+
+namespace :yard do
+
+  cmd = lambda do |command|
+    puts ">> executing: #{command}"
+    system command or raise "#{command} failed"
+  end
+
+  desc 'Pushes generated documentation to github pages: http://ruby-concurrency.github.io/thread_safe/'
+  task :push => [:setup, :yard] do
+
+    message = Dir.chdir(root) do
+      `git log -n 1 --oneline`.strip
+    end
+    puts "Generating commit: #{message}"
+
+    Dir.chdir "#{root}/yardoc" do
+      cmd.call "git add -A"
+      cmd.call "git commit -m '#{message}'"
+      cmd.call 'git push origin gh-pages'
+    end
+
+  end
+
+  desc 'Setups second clone in ./yardoc dir for pushing doc to github'
+  task :setup do
+
+    unless File.exist? "#{root}/yardoc/.git"
+      cmd.call "rm -rf #{root}/yardoc" if File.exist?("#{root}/yardoc")
+      Dir.chdir "#{root}" do
+        cmd.call 'git clone --single-branch --branch gh-pages git@github.com:ruby-concurrency/thread_safe.git ./yardoc'
+      end
+    end
+    Dir.chdir "#{root}/yardoc" do
+      cmd.call 'git fetch origin'
+      cmd.call 'git reset --hard origin/gh-pages'
+    end
+
+  end
+
+end

data/test/test_array.rb

@@ -4,7 +4,7 @@ require File.join(File.dirname(__FILE__), "test_helper")
 class TestArray < Minitest::Test
   def test_concurrency
     ary = ThreadSafe::Array.new
-    (1..100).map do |i|
+    (1..THREADS).map do |i|
       Thread.new do
         1000.times do
           ary << i

data/test/test_cache.rb

@@ -11,7 +11,7 @@ class TestCache < Minitest::Test
 
   def test_concurrency
     cache = @cache
-    (1..100).map do |i|
+    (1..THREADS).map do |i|
       Thread.new do
         1000.times do |j|
           key = i*1000+j

data/test/test_hash.rb

@@ -4,7 +4,7 @@ require File.join(File.dirname(__FILE__), "test_helper")
 class TestHash < Minitest::Test
   def test_concurrency
     hsh = ThreadSafe::Hash.new
-    (1..100).map do |i|
+    (1..THREADS).map do |i|
       Thread.new do
         1000.times do |j|
           hsh[i*1000+j] = i

data/test/test_helper.rb

@@ -1,14 +1,35 @@
-require 'thread'
-require 'rubygems'
-gem 'minitest', '>= 4'
+unless defined?(JRUBY_VERSION)
+  require 'simplecov'
+  require 'coveralls'
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+
+  SimpleCov.start do
+    project_name 'thread_safe'
+
+    add_filter '/examples/'
+    add_filter '/pkg/'
+    add_filter '/test/'
+    add_filter '/tasks/'
+    add_filter '/yard-template/'
+    add_filter '/yardoc/'
+
+    command_name 'Mintest'
+  end
+end
+
 require 'minitest/autorun'
 
-if Minitest.const_defined?('Test')
-  # We're on Minitest 5+. Nothing to do here.
-else
-  # Minitest 4 doesn't have Minitest::Test yet.
-  Minitest::Test = MiniTest::Unit::TestCase
-end
+require 'minitest/reporters'
+Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new(color: true)
+
+require 'thread'
+require 'thread_safe'
+
+THREADS = (RUBY_ENGINE == 'ruby' ? 100 : 10)
 
 if defined?(JRUBY_VERSION) && ENV['TEST_NO_UNSAFE']
   # to be used like this: rake test TEST_NO_UNSAFE=true

data/thread_safe.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["headius@headius.com", "thedarkone2@gmail.com"]
   gem.description   = %q{Thread-safe collections and utilities for Ruby}
   gem.summary       = %q{A collection of data structures and utilities to make thread-safe programming in Ruby easier}
-  gem.homepage      = "https://github.com/headius/thread_safe"
+  gem.homepage      = "https://github.com/ruby-concurrency/thread_safe"
 
   gem.files         = `git ls-files`.split($\)
   gem.files        += ['lib/thread_safe/jruby_cache_backend.jar'] if defined?(JRUBY_VERSION)
@@ -20,7 +20,7 @@ Gem::Specification.new do |gem|
   gem.version       = ThreadSafe::VERSION
   gem.license       = "Apache-2.0"
 
-  gem.add_development_dependency 'atomic', ['>= 1.1.7', '< 2']
+  gem.add_development_dependency 'atomic', '= 1.1.16'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'minitest', '>= 4'
 end

data/yard-template/default/fulldoc/html/css/common.css

@@ -0,0 +1,125 @@
+/* Override this file with custom rules */
+
+body {
+    line-height: 18px;
+}
+
+.docstring code, .docstring .object_link a, #filecontents code {
+    padding: 0px 3px 1px 3px;
+    border: 1px solid #eef;
+    background: #f5f5ff;
+}
+
+#filecontents pre code, .docstring pre code {
+    border: none;
+    background: none;
+    padding: 0;
+}
+
+#filecontents pre.code, .docstring pre.code, .tags pre.example, .docstring code, .docstring .object_link a,
+#filecontents code {
+    -moz-border-radius: 2px;
+    -webkit-border-radius: 2px;
+}
+
+/* syntax highlighting */
+.source_code {
+    display: none;
+    padding: 3px 8px;
+    border-left: 8px solid #ddd;
+    margin-top: 5px;
+}
+
+#filecontents pre.code, .docstring pre.code, .source_code pre {
+    font-family: monospace;
+}
+
+#filecontents pre.code, .docstring pre.code {
+    display: block;
+}
+
+.source_code .lines {
+    padding-right: 12px;
+    color: #555;
+    text-align: right;
+}
+
+#filecontents pre.code, .docstring pre.code,
+.tags pre.example {
+    padding: 5px 12px;
+    margin-top: 4px;
+    border: 1px solid #eef;
+    background: #f5f5ff;
+}
+
+pre.code {
+    color: #000;
+}
+
+pre.code .info.file {
+    color: #555;
+}
+
+pre.code .val {
+    color: #036A07;
+}
+
+pre.code .tstring_content,
+pre.code .heredoc_beg, pre.code .heredoc_end,
+pre.code .qwords_beg, pre.code .qwords_end,
+pre.code .tstring, pre.code .dstring {
+    color: #036A07;
+}
+
+pre.code .fid,
+pre.code .rubyid_new,
+pre.code .rubyid_to_s,
+pre.code .rubyid_to_sym,
+pre.code .rubyid_to_f,
+pre.code .rubyid_to_i,
+pre.code .rubyid_each {
+    color: inherit;
+}
+
+pre.code .comment {
+    color: #777;
+    font-style: italic;
+}
+
+pre.code .const, pre.code .constant {
+    color: inherit;
+    font-weight: bold;
+    font-style: italic;
+}
+
+pre.code .label,
+pre.code .symbol {
+    color: #C5060B;
+}
+
+pre.code .kw,
+pre.code .rubyid_require,
+pre.code .rubyid_extend,
+pre.code .rubyid_include,
+pre.code .int {
+    color: #0000FF;
+}
+
+pre.code .ivar {
+    color: #660E7A;
+}
+
+pre.code .gvar,
+pre.code .rubyid_backref,
+pre.code .rubyid_nth_ref {
+    color: #6D79DE;
+}
+
+pre.code .regexp, .dregexp {
+    color: #036A07;
+}
+
+pre.code a {
+    border-bottom: 1px dotted #bbf;
+}
+

data/yard-template/default/layout/html/footer.erb

@@ -0,0 +1,16 @@
+<div id="footer">
+  Generated on <%= Time.now.strftime("%c") %> by
+  <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  <%= YARD::VERSION %> (ruby-<%= RUBY_VERSION %>).
+</div>
+
+<script>
+  (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+    (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+          m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+  })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+  ga('create', 'UA-57940973-1', 'auto');
+  ga('send', 'pageview');
+
+</script>

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: thread_safe
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.3.5
 platform: java
 authors:
 - Charles Oliver Nutter
@@ -9,26 +9,20 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-05-27 00:00:00.000000000 Z
+date: 2015-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: atomic
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.1.7
-    - - <
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2'
+        version: 1.1.16
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: 1.1.7
-    - - <
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2'
+        version: 1.1.16
   prerelease: false
   type: :development
 - !ruby/object:Gem::Dependency
@@ -68,6 +62,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .travis.yml
+- .yardopts
 - Gemfile
 - LICENSE
 - README.md
@@ -101,6 +96,7 @@ files:
 - lib/thread_safe/util/volatile_tuple.rb
 - lib/thread_safe/util/xor_shift_random.rb
 - lib/thread_safe/version.rb
+- tasks/update_doc.rake
 - test/src/thread_safe/SecurityManager.java
 - test/test_array.rb
 - test/test_cache.rb
@@ -109,7 +105,9 @@ files:
 - test/test_helper.rb
 - test/test_synchronized_delegator.rb
 - thread_safe.gemspec
-homepage: https://github.com/headius/thread_safe
+- yard-template/default/fulldoc/html/css/common.css
+- yard-template/default/layout/html/footer.erb
+homepage: https://github.com/ruby-concurrency/thread_safe
 licenses:
 - Apache-2.0
 metadata: {}
@@ -129,7 +127,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project:
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key:
 specification_version: 4
 summary: A collection of data structures and utilities to make thread-safe programming in Ruby easier
@@ -141,3 +139,4 @@ test_files:
 - test/test_hash.rb
 - test/test_helper.rb
 - test/test_synchronized_delegator.rb
+has_rdoc: