Replace some global Hash usages with the new thread safe cache.

Summary of the changes:
 * Add thread_safe gem.
 * Use thread safe cache for digestor caching.
 * Replace manual synchronization with ThreadSafe::Cache in Relation::Delegation.
 * Replace @attribute_method_matchers_cache Hash with ThreadSafe::Cache.
 * Use TS::Cache to avoid the synchronisation overhead on listener retrieval.
 * Replace synchronisation with TS::Cache usage.
 * Use a preallocated array for performance/memory reasons.
 * Update the controllers cache to the new AS::Dependencies::ClassCache API.
   The original @controllers cache no longer makes much sense after @tenderlove's
   changes in 7b6bfe84f3 and f345e2380c.
 * Use TS::Cache in the connection pool to avoid locking overhead.
 * Use TS::Cache in ConnectionHandler.

1 files changed, 16 insertions, 22 deletions

diff --git a/activerecord/lib/active_record/relation/delegation.rb b/activerecord/lib/active_record/relation/delegation.rb
index 2184625e22..431d083f21 100644
--- a/activerecord/lib/active_record/relation/delegation.rb
+++ b/activerecord/lib/active_record/relation/delegation.rb
@@ -1,5 +1,6 @@
 require 'active_support/concern'
-require 'mutex_m'
+require 'thread'
+require 'thread_safe'
 
 module ActiveRecord
   module Delegation # :nodoc:
@@ -73,8 +74,7 @@ module ActiveRecord
     end
 
     module ClassMethods
-      # This hash is keyed by klass.name to avoid memory leaks in development mode
-      @@subclasses = Hash.new { |h, k| h[k] = {} }.extend(Mutex_m)
+      @@subclasses = ThreadSafe::Cache.new(:initial_capacity => 2)
 
       def new(klass, *args)
         relation = relation_class_for(klass).allocate
@@ -82,33 +82,27 @@ module ActiveRecord
         relation
       end
 
+      # This doesn't have to be thread-safe. relation_class_for guarantees that this will only be
+      # called exactly once for a given const name.
+      def const_missing(name)
+        const_set(name, Class.new(self) { include ClassSpecificRelation })
+      end
+
+      private
       # Cache the constants in @@subclasses because looking them up via const_get
       # make instantiation significantly slower.
       def relation_class_for(klass)
-        if klass && klass.name
-          if subclass = @@subclasses.synchronize { @@subclasses[self][klass.name] }
-            subclass
-          else
-            subclass = const_get("#{name.gsub('::', '_')}_#{klass.name.gsub('::', '_')}", false)
-            @@subclasses.synchronize { @@subclasses[self][klass.name] = subclass }
-            subclass
+        if klass && (klass_name = klass.name)
+          my_cache = @@subclasses.compute_if_absent(self) { ThreadSafe::Cache.new }
+          # This hash is keyed by klass.name to avoid memory leaks in development mode
+          my_cache.compute_if_absent(klass_name) do
+            # Cache#compute_if_absent guarantees that the block will only executed once for the given klass_name
+            const_get("#{name.gsub('::', '_')}_#{klass_name.gsub('::', '_')}", false)
           end
         else
           ActiveRecord::Relation
         end
       end
-
-      # Check const_defined? in case another thread has already defined the constant.
-      # I am not sure whether this is strictly necessary.
-      def const_missing(name)
-        @@subclasses.synchronize {
-          if const_defined?(name)
-            const_get(name)
-          else
-            const_set(name, Class.new(self) { include ClassSpecificRelation })
-          end
-        }
-      end
     end
 
     def respond_to?(method, include_private = false)