Use threads directly, introduce pool later:

db/post_migrate/20170206040400_remove_inactive_default_email_services.rb

@@ -6,24 +6,52 @@ class RemoveInactiveDefaultEmailServices < ActiveRecord::Migration
   disable_ddl_transaction!
 
   def up
-    Gitlab::Database::ThreadedConnectionPool.with_pool(2) do |pool|
-      pool.execute_async <<-SQL.strip_heredoc
+    pool = create_connection_pool
+    threads = []
+
+    threads << Thread.new do
+      pool.with_connection do |connection|
+        connection.execute <<-SQL.strip_heredoc
         DELETE FROM services
           WHERE type = 'BuildsEmailService'
             AND active IS FALSE
             AND properties = '{"notify_only_broken_builds":true}';
-      SQL
+        SQL
+      end
+    end
 
-      pool.execute_async <<-SQL.strip_heredoc
+    threads << Thread.new do
+      pool.with_connection do |connection|
+        connection.execute <<-SQL.strip_heredoc
         DELETE FROM services
           WHERE type = 'PipelinesEmailService'
             AND active IS FALSE
             AND properties = '{"notify_only_broken_pipelines":true}';
-      SQL
+        SQL
+      end
     end
+
+    threads.each(&:join)
   end
 
   def down
     # Nothing can be done to restore the records
   end
+
+  private
+
+  def create_connection_pool
+    # See activerecord-4.2.7.1/lib/active_record/connection_adapters/connection_specification.rb
+    env = Rails.env
+    original_config = ActiveRecord::Base.configurations
+    env_config = original_config[env].merge('pool' => 2)
+    config = original_config.merge(env => env_config)
+
+    spec =
+      ActiveRecord::
+        ConnectionAdapters::
+        ConnectionSpecification::Resolver.new(config).spec(env.to_sym)
+
+    ActiveRecord::ConnectionAdapters::ConnectionPool.new(spec)
+  end
 end

lib/gitlab/database/threaded_connection_pool.rb

-module Gitlab
-  module Database
-    class ThreadedConnectionPool
-      def self.with_pool(pool_size)
-        pool = new(pool_size)
-
-        yield(pool)
-
-      ensure
-        pool.join
-        pool.close
-      end
-
-      def initialize(pool_size)
-        config = ActiveRecord::Base.configurations[Rails.env]
-        @ar_pool = ActiveRecord::Base.establish_connection(
-          config.merge(pool: pool_size))
-        @workers = []
-        @mutex = Mutex.new
-      end
-
-      def execute_async(sql)
-        @mutex.synchronize do
-          @workers << Thread.new do
-            @ar_pool.with_connection do |connection|
-              connection.execute(sql)
-            end
-          end
-        end
-      end
-
-      def join
-        threads = nil
-
-        @mutex.synchronize do
-          threads = @workers.dup
-          @workers.clear
-        end
-
-        threads.each(&:join)
-      end
-
-      def close
-        @ar_pool.disconnect!
-      end
-    end
-  end
-end