Pool de conexões

import pg from "pg";

const pool = new pg.Pool({
  connectionString: process.env.DATABASE_URL,
  max: 5,                         // conexões no máximo, por instância da aplicação
  connectionTimeoutMillis: 1000,  // quanto um pedido espera por uma conexão livre
  idleTimeoutMillis: 30_000,      // fecha conexões paradas há mais de 30 s
  maxLifetimeSeconds: 1800,       // renova cada conexão a cada 30 min
});

// pool.query pega uma conexão e a devolve sozinha, mesmo com erro
async function consultar(sql: string) {
  const inicio = Date.now();
  try {
    await pool.query(sql);
    return `ok em ${Date.now() - inicio} ms`;
  } catch (erro: any) {
    return `falhou em ${Date.now() - inicio} ms: ${erro.message}`;
  }
}

// Cinco consultas lentas ocupam o pool inteiro; a sexta não espera para sempre
const lentas = Array.from({ length: 5 }, () => consultar("SELECT pg_sleep(3)"));
await new Promise((r) => setTimeout(r, 200));
console.log("sexta, com o pool cheio:", await consultar("SELECT 1"));
console.log("lentas:", await Promise.all(lentas));
console.log("depois que liberaram:", await consultar("SELECT 1"));
await pool.end();

import os
import threading
import time

from psycopg_pool import ConnectionPool, PoolTimeout

pool = ConnectionPool(
    os.environ["DATABASE_URL"],
    min_size=1,
    max_size=5,  # conexões no máximo, por instância da aplicação
    timeout=1.0,  # quanto um pedido espera por uma conexão livre
    max_idle=30,  # fecha conexões paradas há mais de 30 s
    max_lifetime=1800,  # renova cada conexão a cada 30 min
    open=True,
)


def consultar(sql: str) -> str:
    inicio = time.monotonic()
    try:
        with pool.connection() as conexao:  # devolve a conexão ao sair, mesmo com erro
            conexao.execute(sql)
        return f"ok em {(time.monotonic() - inicio) * 1000:.0f} ms"
    except PoolTimeout as erro:
        return f"falhou em {(time.monotonic() - inicio) * 1000:.0f} ms: {erro}"


# Cinco consultas lentas ocupam o pool inteiro; a sexta não espera para sempre
lentas = [threading.Thread(target=consultar, args=("SELECT pg_sleep(3)",)) for _ in range(5)]
for t in lentas:
    t.start()
time.sleep(0.2)
print("sexta, com o pool cheio:", consultar("SELECT 1"))
for t in lentas:
    t.join()
print("depois que liberaram:", consultar("SELECT 1"))
pool.close()

package main

import (
	"context"
	"fmt"
	"os"
	"sync"
	"time"

	"github.com/jackc/pgx/v5/pgxpool"
)

func novoPool(ctx context.Context) (*pgxpool.Pool, error) {
	config, err := pgxpool.ParseConfig(os.Getenv("DATABASE_URL"))
	if err != nil {
		return nil, err
	}
	config.MaxConns = 5                       // conexões no máximo, por instância da aplicação
	config.MaxConnIdleTime = 30 * time.Second // fecha conexões paradas há mais de 30 s
	config.MaxConnLifetime = 30 * time.Minute // renova cada conexão a cada 30 min
	return pgxpool.NewWithConfig(ctx, config)
}

// consultar limita a espera pela conexão (e pela consulta) com o prazo do contexto
func consultar(db *pgxpool.Pool, sql string, espera time.Duration) string {
	ctx, cancelar := context.WithTimeout(context.Background(), espera)
	defer cancelar()
	inicio := time.Now()
	if _, err := db.Exec(ctx, sql); err != nil { // Exec devolve a conexão ao terminar
		return fmt.Sprintf("falhou em %d ms: %v", time.Since(inicio).Milliseconds(), err)
	}
	return fmt.Sprintf("ok em %d ms", time.Since(inicio).Milliseconds())
}

func main() {
	db, err := novoPool(context.Background())
	if err != nil {
		panic(err)
	}
	defer db.Close()

	// Cinco consultas lentas ocupam o pool inteiro; a sexta não espera para sempre
	var wg sync.WaitGroup
	for range 5 {
		wg.Go(func() { consultar(db, "SELECT pg_sleep(3)", 10*time.Second) })
	}
	time.Sleep(200 * time.Millisecond)
	fmt.Println("sexta, com o pool cheio:", consultar(db, "SELECT 1", time.Second))
	wg.Wait()
	fmt.Println("depois que liberaram:", consultar(db, "SELECT 1", time.Second))
}

import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.concurrent.Executors;

public class Pool {
    static HikariDataSource novoPool() {
        var config = new HikariConfig();
        config.setJdbcUrl(System.getenv("JDBC_URL"));
        config.setMaximumPoolSize(5);         // conexões no máximo, por instância da aplicação
        config.setConnectionTimeout(1000);    // quanto um pedido espera por uma conexão livre (ms)
        config.setIdleTimeout(30_000);        // fecha conexões paradas há mais de 30 s
        config.setMaxLifetime(1_800_000);     // renova cada conexão a cada 30 min
        return new HikariDataSource(config);
    }

    static String consultar(HikariDataSource pool, String sql) {
        long inicio = System.currentTimeMillis();
        // try-with-resources devolve a conexão ao pool, mesmo com erro
        try (var conexao = pool.getConnection(); var comando = conexao.createStatement()) {
            comando.execute(sql);
            return "ok em " + (System.currentTimeMillis() - inicio) + " ms";
        } catch (SQLException erro) {
            long ms = System.currentTimeMillis() - inicio;
            return "falhou em " + ms + " ms: " + erro.getMessage();
        }
    }

    public static void main(String[] args) throws Exception {
        try (var pool = novoPool(); var executor = Executors.newVirtualThreadPerTaskExecutor()) {
            // Cinco consultas lentas ocupam o pool inteiro; a sexta não espera para sempre
            var lentas = new ArrayList<java.util.concurrent.Future<String>>();
            for (int i = 0; i < 5; i++) {
                lentas.add(executor.submit(() -> consultar(pool, "SELECT pg_sleep(3)")));
            }
            Thread.sleep(200);
            System.out.println("sexta, com o pool cheio: " + consultar(pool, "SELECT 1"));
            for (var l : lentas) l.get();
            System.out.println("depois que liberaram: " + consultar(pool, "SELECT 1"));
        }
    }
}

using System.Diagnostics;
using Npgsql;

// No Npgsql, o pool é configurado na string de conexão
var url = Environment.GetEnvironmentVariable("DATABASE_URL");
var construtor = new NpgsqlConnectionStringBuilder(url)
{
    MaxPoolSize = 5,                 // conexões no máximo, por instância da aplicação
    Timeout = 1,                     // segundos de espera por uma conexão livre
    ConnectionIdleLifetime = 30,     // fecha conexões paradas há mais de 30 s
    ConnectionLifetime = 1800,       // renova cada conexão a cada 30 min
};
await using var db = NpgsqlDataSource.Create(construtor.ConnectionString);

async Task<string> Consultar(string sql)
{
    var relogio = Stopwatch.StartNew();
    try
    {
        await using var comando = db.CreateCommand(sql); // pega e devolve a conexão sozinho
        await comando.ExecuteNonQueryAsync();
        return $"ok em {relogio.ElapsedMilliseconds} ms";
    }
    catch (NpgsqlException erro)
    {
        return $"falhou em {relogio.ElapsedMilliseconds} ms: {erro.Message}";
    }
}

// Cinco consultas lentas ocupam o pool inteiro; a sexta não espera para sempre
var lentas = Enumerable.Range(0, 5).Select(_ => Consultar("SELECT pg_sleep(3)")).ToList();
await Task.Delay(200);
Console.WriteLine($"sexta, com o pool cheio: {await Consultar("SELECT 1")}");
await Task.WhenAll(lentas);
Console.WriteLine($"depois que liberaram: {await Consultar("SELECT 1")}");