Skala anslutningar i PostgreSQL med Connection Pooling

Att öppna en databasanslutning är en dyr operation, och anslutningspoolning används för att hålla databasanslutningar öppna så att de kan återanvändas. Detta undviker att upprepade gånger behöva öppna nätverkssessioner, autentisera och kontrollera auktorisering. Poolning håller anslutningarna aktiva så att, när en anslutning senare efterfrågas, används en av de aktiva istället för att behöva skapa en från början.

Anslutningspoolning

Anslutningspoolning har blivit en av de vanligaste metoderna för att hantera databasanslutningar innan en frågeförfrågan. Vi tror normalt att en anslutning till databasen är snabb men det är inte fallet, särskilt när ett stort antal klienter ansluter. Utan anslutningspoolning skulle en begäran ta upp till 35-50 ms att ansluta men 1-2ms om anslutningspoolning används. Anslutningspooling är därför att förallokera databasanslutningar och sedan återvinna dem när nya klienter ansluter

Skäl till anslutningspoolning

1. För att undvika att din server kraschar. PostgreSQL-servrar är begränsade till ett antal klienter som de hanterar åt gången beroende på minnesparametern. Om detta antal överträffas kommer du att krascha servern. Med anslutningspoolning använder klienter ett visst antal anslutningar.
2. Förenkla bearbetning av frågor. Normalt exekveras databasförfrågningar på ett seriellt sätt med kriteriet först in först ut. Med en stor uppsättning kunder skulle det ta evigheter att uppnå denna process. Därför bör tillvägagångssättet vara att skapa en enda anslutning med förfrågningar i pipeline som kan exekveras samtidigt snarare än var och en åt gången.
3. Förbättra säkerheten. Ofta involverar en anslutning en handskakning som kan ta 25-35 ms i genomsnitt över vilket en SSL upprättas, lösenord kontrolleras och delning av konfigurationsinformation. Allt detta arbete för varje ansluten användare kommer att resultera i omfattande minnesanvändning. Men med anslutningspooling reduceras antalet anslutningar vilket sparar minne.

Typer av anslutningspoolning

Det finns i princip två typer av anslutningspoolning, men det finns en tredje typ av lösning som fungerar som en anslutningspoolningsstrategi som kallas beständiga anslutningar.

Peristent Connection Pooling

Detta tillvägagångssätt avser att hålla en initial anslutning aktiv från det att den initieras. Den håller inte helt anslutningspoolningsfunktionerna men tillräckligt bra för att ge en viss kontinuerlig anslutning. Det är ganska användbart för en liten uppsättning klientanslutningar vars overhead kan variera mellan 25-50 ms. En begränsning med detta tillvägagångssätt är att det är begränsat till ett antal anslutningar till db med normalt en enda anslutning per ingång till servern.

Framework Connection Pooling

Framework anslutningspoolning sker på en applikationsnivå där, närhelst ditt serverskript startas, en pool av anslutningar upprättas för att hantera frågeförfrågningar som kommer att anlända senare.

Fristående anslutningspoolning

För varje anslutning till databasen används ett overheadminne på mellan 5 och 10 MB för att tillgodose en frågeförfrågan. Detta är inte riktigt bra för ett stort antal anslutningar. Användning av anslutningspoolning i ramverket kan begränsas av detta antal anslutningar eftersom det kan stöta på en stor minnesanvändning. Vi väljer därför att använda den fristående anslutningspoolningen som är konfigurerad i enlighet med Postgres-sessioner, uttalanden och transaktioner. Den centrala fördelen med detta tillvägagångssätt är:minimal overheadkostnad på cirka 2 kb för varje anslutning.

När du skapar en anslutningspoolningsklass bör den uppfylla följande faktorer för ökad databasprestanda:

1. Förtilldela anslutningarna
2. Övervaka anslutningar som är tillgängliga
3. Tilldela nya anslutningar
4. Vänta på att en anslutning är tillgänglig
5. Stäng anslutningen

Förtilldelning av anslutningarna

Att säkerställa fler anslutningar i förväg kommer att underlätta hanteringen av förfrågningar vid den tidpunkt då applikationen har startats. Om din server till exempel är utvecklad med Java kan du använda vektorer för att lagra tillgängliga lediga anslutningar med hjälp av koden nedan.

availableConnections = new Vector(connections); 
busyConnections = new Vector();
for(int i=0; i<connections; i++) {
availableConnections.addElement(makeNewConnection()); 
}

Övervaka tillgängliga anslutningar

Klassen bör kunna kontrollera om det finns ledig anslutning i en lista över upptagna anslutningar och returnera den. Detta görs i princip för att återanvända en anslutning eller stänga anslutningar som inte används. Ibland tar anslutningar timeout, så när du returnerar en anslutning är det ganska viktigt att kontrollera om den fortfarande är öppen. Om inte måste du ta bort den här anslutningen och upprepa processen. När en anslutning förkastas öppnas en lucka som kan användas för att bearbeta en ny anslutning när gränsen har nåtts. Detta kan uppnås med

public synchronized Connection getConnection() throws SQLException {
if (!availableConnections.isEmpty()) { Connection existingConnection =
(Connection)availableConnections.lastElement(); int lastIndex = availableConnections.size() - 1; availableConnections.removeElementAt(lastIndex); if (existingConnection.isClosed()) {
notifyAll(); // Freed up a spot for anybody waiting.
return(getConnection()); // Repeat process. } else {
busyConnections.addElement(existingConnection);
return(existingConnection); }
} }

Tilldela en ny anslutning

Du bör kunna starta en bakgrundstråd för att tilldela en ny anslutning om det inte finns någon ledig på och om anslutningsgränsen nästan är nådd.

if ((totalConnections() < maxConnections) && !connectionPending) { // Pending = connecting in bg
makeBackgroundConnection(); }
try {
wait(); // Give up lock and suspend self.
} catch(InterruptedException ie) {} return(getConnection()); // Try again.

Väntar på en ny anslutning

När det inte finns någon ledig anslutning och anslutningsgränsen har nåtts, bör konfigurationen kunna vänta på att en ny anslutning blir tillgänglig utan kontinuerlig pooling. Vi kan göra det med hjälp av väntemetoden som ger ett trådsynkroniseringslås och avbryter tråden tills ett meddelande har lämnats.

try {
     wait();
} catch(InterruptedException ie) {} 
return(getConnection());

För god applikationsetik bör klienter inte vänta i realtid på en anslutning utan du kommer att göra ett undantag när anslutningar saknas med koden nedan:

throw new SQLException("Connection limit reached");

Avsluta anslutningen

När anslutningar samlas in som skräp bör du stänga dem istället för att göra det explicit. Men om du vill ha ett uttryckligt tillvägagångssätt för att stänga en anslutning kan du använda:

public synchronized void closeAllConnections() {
// The closeConnections method loops down Vector, calling // close and ignoring any exceptions thrown. closeConnections(availableConnections); availableConnections = new Vector(); closeConnections(busyConnections);
busyConnections = new Vector();
}

Slutsats

Anslutningspoolning för PostgreSQL hjälper oss att minska antalet resurser som krävs för att ansluta till databasen och förbättrar anslutningshastigheten till databasen. Detta uppnås genom att poola anslutningar till databasen, bibehålla dessa anslutningar och följaktligen minska antalet anslutningar som måste öppnas.