{"canonical_url":"https://engineer.company/sv/glossary/connection-pool/","content_markdown":"# Anslutningspool\n\n## Vad det är\n\nEn anslutningspool är en uppsättning öppna databasanslutningar som en\napplikation håller kvar och lånar ut igen, i stället för att öppna en ny\nanslutning för varje arbetsuppgift och stänga den efteråt. Koden lånar en\nanslutning ur poolen, kör sina satser på den och lämnar tillbaka den, och nästa\nanropare som behöver en får samma anslutning, redan öppen. SQLAlchemys\ndokumentation beskriver pooling som en standardteknik för att hålla långlivade\nanslutningar i minnet så att de kan återanvändas effektivt. Samma sida ger\npoolen ett uppdrag till: den styr hur många anslutningar applikationen får\nanvända samtidigt, så att en plötslig trafiktopp väntar på en ledig anslutning i\nstället för att öppna fler.\n\nEn pool kan ligga på två ställen. Inne i applikationen är den en del av\ndatabasbiblioteket: varje `Engine` i SQLAlchemy har en, och Django kan hålla en\ni varje process för PostgreSQL. Utanför applikationen är den ett eget program\nsom står mellan klienterna och databasservern. PgBouncer är en sådan pooler för\nPostgreSQL: applikationerna ansluter till den som om den vore databasen, och den\nlånar ut serveranslutningar ur sina egna pooler. De två går att kombinera, och\nDjangos databasreferens har ett avsnitt om att köra bakom en transaktionspooler\nsom PgBouncer.\n\nVarför en anslutning är värd att behålla syns på serversidan. PostgreSQL ger\nvarje klient en egen process: en överordnad process, postmaster, lyssnar efter\ninkommande anslutningar och startar en ny serverprocess för varje begäran om\nanslutning, och varje klient är ansluten till exakt en av de processerna. Att\nöppna en anslutning innebär alltså att starta en process på databasservern, och\nen pool betalar det priset en gång och återanvänder sedan resultatet.\n\n## Varför det spelar roll\n\nDet första skälet är kostnaden för att ansluta. Djangos dokumentation säger det\nrakt ut: en beständig anslutning sparar arbetet med att upprätta en ny i varje\nHTTP-förfrågan. Standardinställningen gör ändå det motsatta. `CONN_MAX_AGE` är\n0, vilket stänger anslutningen i slutet av varje förfrågan; ett positivt antal\nsekunder håller den öppen för återanvändning, och `None` håller den öppen utan\ngräns. Det är den enklaste formen av återanvändning, en anslutning per tråd som\nlever längre än förfrågan, och en pool är den allmänna formen.\n\nDet andra skälet är gränsen på servern. PostgreSQLs `max_connections` är\nvanligtvis 100 som standard, kan vara lägre om inställningarna i systemkärnan\ninte klarar det, och kan bara ändras vid serverstart. Tre av platserna är som\nstandard reserverade för superanvändare. Att höja talet är inte heller gratis:\nPostgreSQL dimensionerar vissa resurser, bland annat delat minne, direkt efter\n`max_connections`. Utan en pool håller varje arbetsprocess sin egen anslutning,\noch Djangos dokumentation säger vad det leder till: eftersom varje tråd har sin\negen anslutning måste databasen kunna ta emot minst lika många samtidiga\nanslutningar som det finns arbetstrådar. En pool gör det till ett tal som teamet\nsjälv väljer och kan summera.\n\nDet tredje skälet är hygien. En pool är det enda ställe som varje anslutning\npasserar mellan två lånare, så det är här en anslutning städas och testas. När\nen anslutning kommer tillbaka anropar SQLAlchemys pool `rollback()` på den,\nvilket släpper allt transaktionstillstånd, lås inräknade, så att nästa lånare\ninte ärver en halvfärdig transaktion. I PgBouncers standardläge med sessionspoolning körs dess `server_reset_query`, som standard `DISCARD ALL`, när en serveranslutning släpps och innan en annan klient får den. Och en pool kan testa en\nanslutning innan den lånas ut, vilket spelar roll för anslutningar som har stått\noanvända en tid.\n\n## Så ser det ut i praktiken\n\nI SQLAlchemy 2.1 får varje `Engine` en `QueuePool` som standard, med SQLites\ndatabas i minnet som undantag. Dess `pool_size` är 5 och dess `max_overflow` är\n10, så en engine kan ha upp till 15 anslutningar samtidigt, och en anropare som\nfinner alla upptagna väntar `pool_timeout`, som standard 30 sekunder, innan den\nger upp. Inställningarna är nyckelordsargument till `create_engine()`:\n\n```python\nfrom sqlalchemy import create_engine\n\n# Högst tio anslutningar för den här enginen: tio hålls öppna, inga utöver dem.\nengine = create_engine(\n    \"postgresql+psycopg2://me@localhost/mydb\",\n    pool_size=10,\n    max_overflow=0,\n    pool_timeout=10,  # vänta tio sekunder på en ledig anslutning, ge sedan upp\n    pool_pre_ping=True,  # testa varje anslutning när den lånas ut\n    pool_recycle=3600,  # byt ut anslutningar som är över en timme gamla\n)\n```\n\nMed `pool_pre_ping` kontrollerar poolen vid utlåning att anslutningen\nfortfarande går att använda, via drivrutinens egen ping eller en sats som\nmotsvarar `SELECT 1`. `pool_recycle` är avsett för servrar som stänger\nanslutningar som har stått oanvända en viss tid: med 3600 byts varje anslutning\nsom har varit öppen i mer än en timme ut vid nästa utlåning.\n\nDjango 6.1 har en egen pool för PostgreSQL. Den fungerar bara med drivrutinen\npsycopg och kräver paketet `psycopg[pool]`, och den slås på med `\"OPTIONS\":\n{\"pool\": True}` i databasinställningarna eller med en ordbok med inställningar\nför psycopgs `ConnectionPool`. Poolen återanvänder anslutningar mellan trådar,\noch varje process har en separat pool för varje databasalias. `CONN_MAX_AGE`\nmåste stå kvar på 0 när pooling är påslaget; livslängden för en anslutning i\npoolen sätts i stället med poolens inställning `max_lifetime`. Under ASGI råder\nDjangos dokumentation till att stänga av beständiga anslutningar och använda den\nhär inbyggda poolen i stället.\n\nPgBouncers `pool_mode` avgör när en serveranslutning kan gå vidare till en annan\nklient. I sessionsläge, som är standard, behåller klienten den tills den kopplar\nner. I transaktionsläge har en klient en serveranslutning bara medan en\ntransaktion pågår, så några dussin serveranslutningar kan betjäna långt fler\nklienter. Satsläge släpper anslutningen efter varje fråga och tillåter inte\ntransaktioner som sträcker sig över flera satser. Varje pool rymmer upp till\n`default_pool_size` serveranslutningar per par av användare och databas, som\nstandard 20, och PgBouncer tar emot upp till `max_client_conn`\nklientanslutningar, som standard 100.\n\nFöretagets egna anteckningar placerar poolen tidigt i ordningen.\n[Optimera databasen innan du shardar den](/sv/notes/optimise-before-you-shard/)\nlåter läsaren räkna de aktiva sessionerna i `pg_stat_activity` mot antalet\nCPU-kärnor: när många gånger fler är aktiva än det finns kärnor ägnar servern\nsin tid åt att växla mellan dem, och en anslutningspool löser det innan någon\nhårdvara gör det.\n[Att sälja den sista biljetten exakt en gång](/sv/notes/selling-limited-stock-without-overselling/)\nanvänder samma tanke på en blixtrea: hundratusen köpare ska bli några dussin\nanslutningar genom PgBouncer, inte tusentals serverprocesser som väntar på ett\nenda lås.\n\n## Var det går fel\n\n**Poolerna kräver tillsammans fler anslutningar än servern tillåter.** Varje\npool räknar bara sina egna anslutningar. Med SQLAlchemys standardvärden kan en\nengine nå 15, så tolv processer kan begära 180 från en server där\n`max_connections` vanligtvis är 100 som standard, med tre av dem reserverade för\nsuperanvändare, och Django har en separat pool för varje databasalias i varje\nprocess. Summera det högsta antalet för varje pool som pekar mot databasen, över\nalla processer i alla applikationer och alla schemalagda jobb, och håll summan\nunder `max_connections` minus de reserverade platserna. När det inte går, ställ\nPgBouncer framför och låt den styra antalet serveranslutningar.\n\n**En anslutning dör medan den väntar i poolen.** En anslutning som har stått\noanvänd kan stängas i andra änden utan att poolen vet om det, och nästa lånare\nmisslyckas då på sin första sats. Slå på `pool_pre_ping` i SQLAlchemy eller\n`CONN_HEALTH_CHECKS` i Django, som testar en återanvänd anslutning en gång per\nförfrågan, och sätt `pool_recycle` eller psycopgs `max_lifetime` lägre än den\ntid efter vilken servern stänger oanvända anslutningar. Ingen av dem täcker en\nanslutning som bryts mitt i en transaktion: SQLAlchemys dokumentation säger\ntydligt att pre-ping inte hanterar det fallet, så applikationen måste själv göra\nom arbetet.\n\n**En arbetsprocess som startas med fork ärver förälderns anslutningar.** En\nwebbserver eller en jobbkörare som skapar sin engine och sedan startar sina\narbetsprocesser med fork lämnar varje barn med samma poolanslutningar som\nföräldern. SQLAlchemys dokumentation kallar det kritiskt att poolanslutningar\ninte delas med en process som startats med fork, eftersom båda processerna då\nskulle tala över samma nätverksanslutning. Följ det rekommenderade\ntillvägagångssättet och anropa `engine.dispose(close=False)` i varje barns\ninitializer, så att barnet börjar med en tom pool och lämnar förälderns\nanslutningar i fred. Alternativen är `NullPool`, som öppnar och stänger en\nanslutning vid varje användning, eller att anropa `engine.dispose()` före\nfork-anropet.\n\n**Transaktionspooling förstör sessionstillstånd.** I PgBouncers transaktionsläge\nkan två transaktioner från samma klient köras på olika serveranslutningar, så\ninget av det en klient ställer in för sin session finns garanterat kvar i dess\nnästa transaktion. PgBouncers funktionslista markerar `SET`, `LISTEN`, markörer\ndeklarerade med `WITH HOLD`, `PREPARE` på SQL-nivå och advisory locks på\nsessionsnivå som aldrig stödda i det läget, och sticker inte under stol med att\nläget till sin natur bryter några av de antaganden klienter gör om servern. Håll\nsessionstillstånd borta från kod som går genom en transaktionspooler, och skicka\nde klienter som behöver det till en pool i sessionsläge. I Django ska\n`DISABLE_SERVER_SIDE_CURSORS` sättas till `True` för en databas bakom en\ntransaktionspooler, annars måste frågorna köras inne i `atomic()`.\n\n## Läs mer\n\n- [Connection Pooling](https://docs.sqlalchemy.org/en/21/core/pooling.html)\n  — `QueuePool` och dess standardvärden, hantering av brutna anslutningar,\n  återställning vid retur och pooler vid fork i SQLAlchemy 2.1.\n- [PgBouncer features](https://www.pgbouncer.org/features.html)\n  — sessions-, transaktions- och satsläge, och vilka PostgreSQL-funktioner vart\n  och ett av dem stöder.\n- [PgBouncer configuration](https://www.pgbouncer.org/config.html)\n  — `pool_mode`, `default_pool_size`, `max_client_conn` och tidsgränserna med\n  sina standardvärden.\n- [How Connections Are Established](https://www.postgresql.org/docs/current/connect-estab.html)\n  — PostgreSQLs modell med en process per användare och postmaster-processen.\n- [Connections and Authentication](https://www.postgresql.org/docs/current/runtime-config-connection.html)\n  — `max_connections` och de anslutningsplatser som är reserverade för\n  superanvändare och andra roller.\n- [Databases](https://docs.djangoproject.com/en/stable/ref/databases/)\n  — beständiga anslutningar, PostgreSQL-poolen och transaktionspooling i Djangos\n  referens.\n\n\u003chttps://engineer.company/sv/glossary/connection-pool/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Varför en databasanslutning är värd att behålla, hur en pool återanvänder och begränsar anslutningar, vad PgBouncers lägen ändrar, och fyra fallgropar.","formats":{"gemtext":"https://engineer.company/sv/glossary/connection-pool/index.gmi","gopher":"https://engineer.company/sv/glossary/connection-pool/gophermap","html":"https://engineer.company/sv/glossary/connection-pool/","json":"https://engineer.company/sv/glossary/connection-pool/index.json","markdown":"https://engineer.company/sv/glossary/connection-pool/index.md","pdf":"https://engineer.company/sv/glossary/connection-pool/index.pdf"},"kind":"page","language":"sv","title":"Vad är en anslutningspool?","url":"https://engineer.company/sv/glossary/connection-pool/","version":1}