why use wait_for_termination method will stuck the code about concurrent-ruby HOT 2 OPEN

class ClassFactory
  def self.create_dynamic_model(database_name, table_name, deletable=false)
    new_class = self.name + database_name.camelize + table_name.singularize.camelize
    
    if deletable
      existing_classes = ActiveRecord::Base.descendants.reject(&:abstract_class).select{ |m| m.table_name == table_name && m.database_name == database_name }

      if existing_classes.length == 1
        include_delete_restore(existing_classes[0])
        return existing_classes[0]
      end

      if existing_classes.length > 1
        primary = find_primary_existing_class(existing_classes)
        if primary.present?
          include_delete_restore(primary)
          return primary
        end
      end
    end

    existing_class = begin
      k = Module.const_get(new_class)
      if k.database_name == database_name && k.table_name == table_name
        k
      end
    rescue NameError
      nil
    end
    
    if existing_class
      include_delete_restore(existing_class) if deletable
      return existing_class
    end
    
    Object.const_set(new_class, Class.new(database_name == 'one_eye' ? ActiveRecord::Base : "#{database_name.camelcase}DatabaseRecord".constantize))
    klass = new_class.constantize
    klass.table_name = table_name
    klass.inheritance_column = nil

    if klass.primary_key == nil
      # Rails can't handle composite PKs.
      # We have to retrieve from the schema cache and explicitly set
      key = klass.connection.schema_cache.primary_keys(table_name)
      klass.primary_key = key
    end

    include_delete_restore(klass) if deletable
    klass
  end

  private

  def self.include_delete_restore(klass)
    klass.include(DeleteRestore::Deletable)
    klass.include(DeleteRestore::Restorable)
  end

  def self.find_primary_existing_class(existing_classes)
    # First check to see if any have been marked as primary
    primary = existing_classes.select { |c| c.instance_variable_defined?(:@primary_model_for_table) && c.instance_variable_get(:@primary_model_for_table) }
    return primary[0] if primary.length == 1

    # Then check to see if only one implements Deletable
    deletable = existing_classes.select { |c| c < DeleteRestore::Deletable }
    return deletable[0] if deletable.length == 1

    # Check to see if only one override the delete_batch method
    overriding = existing_classes.select { |c| c.respond_to?(:delete_batch) && c.method(:delete_batch).owner != DeleteRestore::Deletable::ClassMethods } 
    return overriding[0] if overriding.length == 1

    # If we can't narrow it down, return nil
    return nil
  end
end