Make start/clean more threadsafe

* Prevent other threads from modifying the tables we're deleting from
  * Used read_committed since it's the lowest level that works
  * Tested various isolations:
    * read_uncommitted - works, but PG treats it as read_committed[1]
    * read_committed - works
    * repeatable_read - skipped
    * serializable - works (highest isolation level)
* Don't allow changes to table_max_id_cache by other threads while we're
accessing it

[1] https://www.postgresql.org/docs/13/transaction-iso.html
"In PostgreSQL, you can request any of the four standard transaction isolation
levels, but internally only three distinct isolation levels are implemented,
i.e., PostgreSQL's Read Uncommitted mode behaves like Read Committed. This is
because it is the only sensible way to map the standard isolation levels to
PostgreSQL's multiversion concurrency control architecture."

Author: jrafanie

lib/extensions/database_cleaner-activerecord-seeded_deletion.rb

@@ -1,12 +1,18 @@
 require 'database_cleaner-active_record'
+require 'thread'
 
 module DatabaseCleaner
   module ActiveRecord
     # SeededDeletion is a strategy that deletes all records from tables except those that existed before it was instantiated
     # This is useful for tests that need the seeded data to be present.
     class SeededDeletion < Deletion
+      # Class level mutex for thread safety around start/clean actions.
+      @mutex = Mutex.new
+
       def clean
-        connection.transaction(:requires_new => true) do
+        # Use a transaction isolation to prevent other threads
+        # from modifying the tables during deletion
+        connection.transaction(:requires_new => true, :isolation => :read_committed) do
           super
         end
       end
@@ -17,12 +23,14 @@ def start
       end
 
       def self.table_max_id_cache
-        @table_max_id_cache ||= {}
+        # wrap the cache initialization in a mutex to ensure thread safety
+        @mutex.synchronize { @table_max_id_cache ||= {} }
       end
 
-      # Memoize the maximum ID for each class table with non-zero number of rows
       def self.table_max_id_cache=(table_id_hash)
-        @table_max_id_cache ||= table_id_hash
+        @mutex.synchronize do
+          @table_max_id_cache = table_id_hash
+        end
       end
 
       delegate :table_max_id_cache, to: :class