Active Record 连接池

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 120
def initialize(pool_config)
  super()

  @pool_config = pool_config
  @db_config = pool_config.db_config
  @role = pool_config.role
  @shard = pool_config.shard

  @checkout_timeout = db_config.checkout_timeout
  @idle_timeout = db_config.idle_timeout
  @size = db_config.pool

  # This variable tracks the cache of threads mapped to reserved connections, with the
  # sole purpose of speeding up the +connection+ method. It is not the authoritative
  # registry of which thread owns which connection. Connection ownership is tracked by
  # the +connection.owner+ attr on each +connection+ instance.
  # The invariant works like this: if there is mapping of <tt>thread => conn</tt>,
  # then that +thread+ does indeed own that +conn+. However, an absence of such
  # mapping does not mean that the +thread+ doesn't own the said connection. In
  # that case +conn.owner+ attr should be consulted.
  # Access and modification of <tt>@thread_cached_conns</tt> does not require
  # synchronization.
  @thread_cached_conns = Concurrent::Map.new(initial_capacity: @size)

  @connections         = []
  @automatic_reconnect = true

  # Connection pool allows for concurrent (outside the main +synchronize+ section)
  # establishment of new connections. This variable tracks the number of threads
  # currently in the process of independently establishing connections to the DB.
  @now_connecting = 0

  @threads_blocking_new_connections = 0

  @available = ConnectionLeasingQueue.new self

  @lock_thread = false

  @async_executor = build_async_executor

  @reaper = Reaper.new(self, db_config.reaping_frequency)
  @reaper.run
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 196
def active_connection?
  @thread_cached_conns[connection_cache_key(current_thread)]
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 363
def checkin(conn)
  conn.lock.synchronize do
    synchronize do
      remove_connection_from_thread_cache conn

      conn._run_checkin_callbacks do
        conn.expire
      end

      conn.lock_thread = nil
      @available.add conn
    end
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 352
def checkout(checkout_timeout = @checkout_timeout)
  connection = checkout_and_verify(acquire_connection(checkout_timeout))
  connection.lock_thread = @lock_thread
  connection
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 310
def clear_reloadable_connections(raise_on_acquisition_timeout = true)
  with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
    synchronize do
      @connections.each do |conn|
        if conn.in_use?
          conn.steal!
          checkin conn
        end
        conn.disconnect! if conn.requires_reloading?
      end
      @connections.delete_if(&:requires_reloading?)
      @available.clear
    end
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 334
def clear_reloadable_connections!
  clear_reloadable_connections(false)
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 233
def connected?
  synchronize { @connections.any? }
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 181
def connection
  @thread_cached_conns[connection_cache_key(current_thread)] ||= checkout
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 248
def connections
  synchronize { @connections.dup }
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 258
def disconnect(raise_on_acquisition_timeout = true)
  with_exclusively_acquired_all_connections(raise_on_acquisition_timeout) do
    synchronize do
      @connections.each do |conn|
        if conn.in_use?
          conn.steal!
          checkin conn
        end
        conn.disconnect!
      end
      @connections = []
      @available.clear
    end
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 280
def disconnect!
  disconnect(false)
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 435
def flush(minimum_idle = @idle_timeout)
  return if minimum_idle.nil?

  idle_connections = synchronize do
    return if self.discarded?
    @connections.select do |conn|
      !conn.in_use? && conn.seconds_idle >= minimum_idle
    end.each do |conn|
      conn.lease

      @available.delete conn
      @connections.delete conn
    end
  end

  idle_connections.each do |conn|
    conn.disconnect!
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 457
def flush!
  reap
  flush(-1)
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 164
def lock_thread=(lock_thread)
  if lock_thread
    @lock_thread = ActiveSupport::IsolatedExecutionState.context
  else
    @lock_thread = nil
  end

  if (active_connection = @thread_cached_conns[connection_cache_key(current_thread)])
    active_connection.lock_thread = @lock_thread
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 412
def reap
  stale_connections = synchronize do
    return if self.discarded?
    @connections.select do |conn|
      conn.in_use? && !conn.owner.alive?
    end.each do |conn|
      conn.steal!
    end
  end

  stale_connections.each do |conn|
    if conn.active?
      conn.reset!
      checkin conn
    else
      remove conn
    end
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 207
def release_connection(owner_thread = ActiveSupport::IsolatedExecutionState.context)
  if conn = @thread_cached_conns.delete(connection_cache_key(owner_thread))
    checkin conn
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 380
def remove(conn)
  needs_new_connection = false

  synchronize do
    remove_connection_from_thread_cache conn

    @connections.delete conn
    @available.delete conn

    # @available.any_waiting? => true means that prior to removing this
    # conn, the pool was at its max size (@connections.size == @size).
    # This would mean that any threads stuck waiting in the queue wouldn't
    # know they could checkout_new_connection, so let's do it for them.
    # Because condition-wait loop is encapsulated in the Queue class
    # (that in turn is oblivious to ConnectionPool implementation), threads
    # that are "stuck" there are helpless. They have no way of creating
    # new connections and are completely reliant on us feeding available
    # connections into the Queue.
    needs_new_connection = @available.any_waiting?
  end

  # This is intentionally done outside of the synchronized section as we
  # would like not to hold the main mutex while checking out new connections.
  # Thus there is some chance that needs_new_connection information is now
  # stale, we can live with that (bulk_make_new_connections will make
  # sure not to exceed the pool's @size limit).
  bulk_make_new_connections(1) if needs_new_connection
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 469
def stat
  synchronize do
    {
      size: size,
      connections: @connections.size,
      busy: @connections.count { |c| c.in_use? && c.owner.alive? },
      dead: @connections.count { |c| c.in_use? && !c.owner.alive? },
      idle: @connections.count { |c| !c.in_use? },
      waiting: num_waiting_in_queue,
      checkout_timeout: checkout_timeout
    }
  end
end

# File activerecord/lib/active_record/connection_adapters/abstract/connection_pool.rb, line 222
def with_connection
  unless conn = @thread_cached_conns[connection_cache_key(ActiveSupport::IsolatedExecutionState.context)]
    conn = connection
    fresh_connection = true
  end
  yield conn
ensure
  release_connection if fresh_connection
end