{"canonical_url":"https://engineer.company/sv/notes/selling-limited-stock-without-overselling/","content_markdown":"# Att sälja den sista biljetten exakt en gång\n\n2026-10-13\n\nEn blixtrea ställer tiotusen enheter framför en miljon människor på en gång. Det\nintressanta felet är inte att butiken går ned. Det är att butiken håller sig\nuppe och säljer tiotusenfyrtio. Instinkten som följer — databasen är för liten,\nsharda den — svarar på en fråga som ingen har ställt. Databasen var aldrig för\nstor. Varje köpare skrev till\nsamma rad *(hela incidenten bor i en enda rad)*.\n\nVi plockar här isär problemet innan det når ett projekt: var taket kommer ifrån,\nden enda sats som tar bort det mesta av det, och vad man bygger när en enda\ndatabas verkligen inte räcker.\n\n## En rad, alla köpare\n\nTjugo miljoner rader utspridda över ett kluster är ett löst problem. En rad som\nvarje begäran måste ändra är det inte, och fler maskiner rör den inte, eftersom\nraden finns på en av dem. Distribuerade lagringssystem säger det rakt ut:\nDynamoDB ger en enskild partition ungefär 1 000 skrivenheter per sekund, och\nvarje skrivning till ett objekt hamnar på det objektets partition, hur många\nandra det än finns.\n\nDet finns ett teorem bakom formen. Bailis med kolleger kallar en invariant för\ninvariant-confluent när repliker kan ta emot skrivningar var för sig och ändå\nslås samman till ett giltigt tillstånd. `stock \u003e= 0` är skolboksexemplet på en\nsom inte är det: två repliker som var och en ser en enhet kvar säljer den båda,\noch ingen sammanslagning kan ta tillbaka den andra försäljningen. Att aldrig\növersälja kräver samordning. Den enda frågan är hur mycket av den varje\nförsäljning betalar för.\n\n## Talet som avgör\n\nTaket för en vara är ungefär hur många försäljningar ett lås bär, delat med hur\nlänge låset hålls:\n\n```text\nmax försäljningar/s per vara ≈ försäljningar per lås ÷ låsets hålltid\n```\n\n| Vad som håller raden        | Tak per rad  |\n| --------------------------- | ------------ |\n| Lås, anropa sedan betalning | ~2/s         |\n| Lås, kör sedan applogik     | ~100–200/s   |\n| En villkorad `UPDATE`       | ~500–2 000/s |\n| Batchar om 100 per commit   | ~50 000/s    |\n| En skrivare i minnet        | ~100 000+/s  |\n\nDet här är storleksordningar, inte benchmarkresultat; hårdvaran flyttar dem. Det\nden inte flyttar är formen. Det mesta av ett kort lås är commiten som väntar på\natt dess logg ska nå disken, och därför vinner batchning med två\nstorleksordningar: hundra försäljningar delar på en enda skrivning till disk.\n\nDet lämnar fyra spakar, och varje lösning nedan drar i en av dem:\n\n1. **Håll låset kortare tid** — en sats, ingenting över nätverket inuti den.\n2. **Gör mer per lås** — batcha nedräkningarna.\n3. **Ha fler lås** — dela upp lagersaldot på flera nycklar.\n4. **Skicka färre begäranden till låset** — avvisa de flesta köpare innan de\n   når det.\n\nDen sista betyder mer än det låter. Med en miljon köpare och tiotusen enheter\nmåste 990 000 begäranden misslyckas. Avvisningar är det mesta av trafiken, så\n”slutsålt” måste vara det billigaste svar systemet ger: ett väntrum framför\nförsäljningen, en grind som släpper in ungefär lika många köpare som det finns\nenheter, en `sold_out`-flagga som CDN:et serverar utan att fråga någon, och en\nhastighetsbegränsning per konto.\n\n## Åtgärda den enda databasen först\n\nVersionen som kryper fram, eller översäljer, ser oftast ut så här:\n\n```sql\nBEGIN;\nSELECT available FROM inventory\n WHERE item_id = :item FOR UPDATE;\n-- applikationen kontrollerar talet,\n-- och anropar kanske en betalningsleverantör\nUPDATE inventory SET available = :new\n WHERE item_id = :item;\nCOMMIT;\n```\n\nLåset är rätt. Det som det hålls över är fel: varje millisekund som\napplikationen tillbringar mellan `SELECT` och `UPDATE` är en millisekund som\nnästa köpare väntar. Utan `FOR UPDATE` är det värre. Två köpare läser 1, båda\nskriver 0, och en enhet har sålts två gånger.\n\nLösningen gör kontrollen och nedräkningen till en enda sats:\n\n```sql\nUPDATE inventory\n   SET available = available - :qty\n WHERE tenant_id = :tenant\n   AND item_id = :item\n   AND available \u003e= :qty\nRETURNING available;\n-- en rad tillbaka: reserverad. ingen: slutsåld.\n```\n\nI PostgreSQL med READ COMMITTED väntar en andra köpare som når raden medan den\nförsta håller den, och utvärderar sedan `WHERE`-villkoret på nytt mot raden som\nden första committade. Om den försäljningen tog den sista enheten uppfylls inte\nvillkoret, och den andra köparen får ingen rad tillbaka — slutsålt — i stället\nför ett negativt tal. Med REPEATABLE READ eller SERIALIZABLE får den andra\nköparen i stället ett serialiseringsfel, vilket är säkert men gör konkurrensen\nom raden till omförsök; READ COMMITTED är den nivå som den här satsen är skriven\nför. InnoDB i MySQL kommer fram till samma svar, eftersom en `UPDATE` där läser\nden senast committade raden på alla nivåer. Lägg också till integritetsvillkoret,\nså att en bugg någon annanstans misslyckas högljutt i stället för att sälja\nlager som inte finns:\n\n```sql\nALTER TABLE inventory\n  ADD CONSTRAINT available_not_negative\n  CHECK (available \u003e= 0);\n```\n\nDärefter resten av arbetet med en enda databas, ungefär i ordning efter vad det\nger:\n\n- **Inget externt inuti transaktionen.** Inget betalningsanrop, ingen\n  HTTP-begäran, inget publicerat meddelande. De hör hemma före transaktionen\n  eller efter den.\n- **Rör den heta raden sist.** Infoga ordern och allt annat först, så att låset\n  på raden som flera transaktioner konkurrerar om bara varar under den sista\n  satsen och commiten.\n- **Ingen optimistisk låsning på en het räknare.** En versionskolumn gör\n  konkurrens till omförsök, och under en rea är omförsöken själva lasten.\n- **Servera läsningarna från något annat ställe.** Produktsidans ”12 kvar” kan\n  komma från en replik eller en cache som ligger en sekund efter. Bara\n  försäljningen behöver primärnoden.\n- **Ge lagret en egen databas,** så att en försäljning aldrig köar bakom\n  katalogen för samma disk.\n- **Poola anslutningarna.** Hundratusen köpare ska vara några dussin\n  anslutningar genom PgBouncer, inte tusentals backendprocesser som köar för\n  ett enda lås.\n\nSittplatser har en annan form, eftersom varje enhet är unik, och de kräver en\nannan sats. Varje plats är en rad, och en köpare hoppar över de rader som en\nannan transaktion håller i stället för att köa bakom dem:\n\n```sql\nUPDATE seats\n   SET held_by = :order,\n       held_until = now() + interval '10 min'\n WHERE id = (\n   SELECT id FROM seats\n    WHERE event_id = :event\n      AND sold_at IS NULL\n      AND (held_until IS NULL\n           OR now() \u003e held_until)\n    LIMIT 1\n    FOR UPDATE SKIP LOCKED)\nRETURNING id;\n```\n\nEn reservation som har löpt ut är helt enkelt tillgänglig igen, så det behövs\ningen städprocess för att svaret ska bli rätt. Och `now()` är databasens klocka,\nså applikationsservrar vars klockor går olika kan inte vara oense om när en\nreservation tog slut.\n\nFör många butiker är det här avsnittet hela lösningen. Gör det före allt nedan,\neftersom sharding är en enkelriktad dörr: lätt att gå igenom, dyr att gå\ntillbaka genom.\n\n## Reservera först, betala sedan\n\nEn köpare som tar den sista enheten och sedan överger kortformuläret har inte\nköpt den. En försäljning är alltså inte en skrivning utan en kort livscykel:\n\n```text\nAVAILABLE → HELD, i minuter → SOLD\n                            → RELEASED\n```\n\n- **Reservationen nycklas på begäran, inte på försöket.** Varje köp i kassan bär\n  en idempotensnyckel, och reservationstabellen har\n  `UNIQUE (tenant_id, idempotency_key)`, så att ett upprepat klick får tillbaka\n  den reservation det redan har i stället för en andra enhet. En detalj i\n  PostgreSQL biter här: `INSERT ... ON CONFLICT DO NOTHING RETURNING id`\n  returnerar ingenting när raden redan fanns, så ”ingen rad tillbaka” betyder\n  ”slå upp den”, inte ”misslyckades”.\n- **Varje övergång är villkorad.** Att bekräfta en försäljning flyttar en\n  reservation från `held` till `sold` bara där den fortfarande är `held`, och\n  att släppa en reservation lägger tillbaka enheten i lagersaldot bara om den\n  egna uppdateringen ändrade exakt en rad. Ett släpp som körs två gånger — t.ex.\n  timeouten och avbrytknappen — lämnar tillbaka enheten en gång.\n- **Reservationer löper ut efter minuter.** Fem till tio är vanligt. Förläng\n  reservationen en gång när betalningen startar, så att ett långsamt kort inte\n  förlorar den enhet det betalar för.\n- **Begränsa antalet enheter per köpare vid reservationen,** så att ett\n  konto inte kan hålla hela lagret medan det bestämmer sig.\n\nUnder alltihop ligger en rad, den mest användbara i lösningen:\n\n```text\navailable + held + sold = total\n```\n\nDen gäller efter varje transaktion, en enda SQL-fråga kontrollerar den, och när\nden slutar gälla har något översålt eller tappat en enhet — innan en kund säger\ndet.\n\n## När en databas inte räcker\n\nIbland räcker den verkligen inte: många tenants, många reor\nsamtidigt, flera regioner. Strukturen som skalar behåller en regel — varje vara\nhar exakt en ägare av sitt lagersaldo, en lagertjänst, och ingenting annat\nbestämmer — och shardar den tjänsten på `(tenant_id, item_id)`, så att en varas\nskrivningar aldrig spänner över två shards. De största tenanterna får egna\nceller, så att deras rea inte kan svälta ut någon annans. Bara reservationen\nmåste vara synkron; allt efter den kan vara ett meddelande.\n\nFör den heta varan inuti en shard finns det fyra verktyg, och vart och ett drar\ni en av spakarna ovan.\n\n**En grind framför.** En Redis-räknare, som räknas ned av ett Lua-skript så att\nkontrollen och nedräkningen blir ett enda steg, släpper in ungefär lika många\nköpare som det finns enheter och avvisar alla andra på mikrosekunder. Den är\ninte den som avgör. Redis replikerar asynkront, så efter en failover kan den nya\nprimärnoden ha glömt några insläpp och släppt igenom några för många.\nDatabasens villkorade `UPDATE` avgör fortfarande, och en avstämningsprocess\nåterställer grinden från databasens tal.\n\n**Dela upp lagersaldot.** Tiotusen enheter kan vara hundra hinkar om hundra,\nvar och en sin egen rad eller sin egen shard, med varje köpare skickad till en\nav dem: hundra lås i stället för ett. Idén är gammal — O'Neils\nescrow-transaktioner 1986, sedan demarkationsprotokollet från Barbará och\nGarcia-Molina, sedan de begränsade räknarna från Balegas med kolleger — och dess\nenda verkliga kostnad är svansen. En köpares hink tar slut medan andra\nfortfarande har lager, så antingen prövar man en annan hink eller flyttar\nresterna, och mot slutet av en rea slår man ihop dem till en igen. Samma idé ger\nvarje region en egen kvot, så att de flesta försäljningar aldrig korsar ett hav\nför att fråga.\n\n**En skrivare per vara.** Lägg varje begäran för en vara på en Kafka-partition,\nläst av en enda konsument som håller räkningen i minnet och committar sina\nbeslut i batchar. En tråd och inga lås: LMAX-formen. Begäranden bär ett id, och\nskrivaren kastar en som den redan har avgjort, eftersom en kö levererar två\ngånger.\n\n**Enheter som rader.** När enheterna är få och unika — sittplatser, numrerade\nutgåvor — skapa en rad per enhet i förväg och ta dem med `SKIP LOCKED` som ovan,\neller håll enheternas id i en Redis-mängd och ta en med `SPOP`. Det finns ingen\nräknare kvar att slåss om.\n\n## Resten av köpflödet\n\nBetalningen, ordern och kvittot är separata system, och ingen transaktion\nspänner över dem. Tvåfas-commit är skolboksvaret och fel svar här: den blockerar\nså länge någon deltagare är långsam, den lägger till fler nätverksrundor på den\nhetaste vägen, och betalningsleverantörer deltar inte i den. En saga gör jobbet,\nen sekvens av lokala steg, vart och ett med ett steg som ångrar det:\n\n```text\n1. reservera lager       ångra: släpp reservationen\n2. väntande order        ångra: avbryt ordern\n3. förläng reservationen (löper ut av sig själv)\n4. auktorisera betalning ångra: annullera den\n5. bekräfta HELD → SOLD\n6. dra betalningen\n```\n\nAtt auktorisera först och dra betalningen sist betyder att en betalning som\nkommer fram efter att dess reservation har löpt ut annulleras i stället för att\nåterbetalas: pengarna flyttades aldrig. Varje steg skriver sitt meddelande till\nen outbox-tabell i samma transaktion som ändringen det meddelar, och change data\ncapture publicerar det, så att ingenting går förlorat mellan sparat och skickat.\nVarje konsument är idempotent, nycklad på ordern. Meddelanden kommer fram minst\nen gång, och idempotensen gör det i praktiken till en gång.\n\nEtt distribuerat lås hör inte hemma någonstans i det här. Kleppmanns poäng är\natt den som håller ett lås kan bli pausad längre än låsets lease-tid — en\nskräpsamling, en virtuell maskin som står still — och fortsätta skriva, och\nbotemedlet är en fencing-token som lagringssystemet kontrollerar. Men ett\nlagringssystem som kan kontrollera en token kan kontrollera `available \u003e= :qty`,\noch då behövde det aldrig låset.\n\n## Pausa varan, översälj den aldrig\n\nKonsistens och tillgänglighet väljs per fråga, inte per system. ”Kan jag sälja\nden här enheten?” måste vara konsistent: när ägaren av en varas lagersaldo inte\ngår att nå slutar den varan att säljas. Allt annat — katalogen, märket med\n”3 kvar”, orderhistoriken — kan förbli tillgängligt och vara lite inaktuellt.\n\nDen tystaste översäljningen kommer från en failover. Med asynkron replikering\nbekräftar en primärnod en försäljning och dör innan dess replik har fått den;\nrepliken befordras, försäljningen är borta, och enheten säljs igen. Lösningen är\natt göra en försäljning beständig på mer än en maskin innan den bekräftas: en\nsynkron standby i PostgreSQL (`synchronous_commit` med\n`synchronous_standby_names`), eller ett lagringssystem byggt på Raft. Det kostar\nlatens vid varje commit, vilket förlänger precis den låshålltid som taket delas\nmed, och batchning och grinden köper tillbaka den. Avgränsa också pausen: en\nshard som har gått ned ska stoppa varorna på den, inte butiken.\n\n## Bevisa det\n\nInget av detta ska tas på tro, inte ens det vi säger.\n\n- **Bevaka invarianten.** Kör `available + held + sold = total` schemalagt, visa\n  den i ett diagram och larma vid varje avvikelse. Noll översäljningar är ett\n  servicenivåmål med ett larm, inte en förhoppning.\n- **Framkalla kapplöpningen med flit.** Tiotusen samtidiga köpare för hundra\n  enheter, i testsviten, med kontroll av att exakt hundra såldes och att inget\n  tal gick under noll.\n- **Ha sönder saker under kapplöpningen.** Döda primärnoden, kapa nätverket,\n  pausa en process — i Jepsen-stil — och kontrollera invarianten efteråt.\n- **Lasttesta avvisningarna.** Vägen för slutsålt måste förbli snabb när den är\n  99 % av trafiken, och edge-nätverket måste ta upp den.\n- **Samla mätvärdena på en instrumentpanel:** låsväntetider, utgångna\n  reservationer och avståndet mellan grindens räkning och databasens.\n\n## I vilken ordning\n\n1. Mät först. `pg_stat_statements` och låsväntetiderna visar om den heta raden\n   alls är problemet.\n2. Gör skrivningen till en enda villkorad sats.\n3. Minska lasten: ett väntrum, en grind, ett cachat ”slutsålt”.\n4. Ge lagret en egen tjänst och en egen ägare.\n5. Sharda på `(tenant_id, item_id)`, och bara om de fyra första inte räckte.\n6. Lägg till ett läge för heta varor, hinkar eller en enda skrivare, för den rea\n   du vet kommer.\n7. Regioner sist, med kvoter.\n\n## Vad vi skulle säga till nästa person\n\n- **Sharding svarar på en annan fråga.** Den sprider många rader, och en\n  översåld rea är en enda rad. Ta reda på vilket du har innan du bygger.\n- **Gör kontrollen och nedräkningen till en sats.** Det mesta av avståndet\n  mellan bra och översålt är tiden mellan att läsa ett tal och att skriva det.\n- **Det mesta av trafiken är svaret nej.** Gör avvisningen till det billigaste\n  systemet gör.\n- **Pausa innan du översäljer.** En vara som slutar säljas i trettio sekunder\n  blir en ursäkt. En vara som säljs två gånger blir en återbetalning, en\n  supportkö och en kund som minns.\n- **Skriv ned invarianten och bevaka den.** Den är en rad, och den är det enda\n  som visar att lösningen fungerar i produktion snarare än i granskningen.\n\n## Källor\n\n- [PostgreSQL: isoleringsnivån Read Committed](https://www.postgresql.org/docs/current/transaction-iso.html#XACT-READ-COMMITTED)\n- [PostgreSQL: `FOR UPDATE` och `SKIP LOCKED`](https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE)\n- [PostgreSQL: synkron replikering](https://www.postgresql.org/docs/current/warm-standby.html#SYNCHRONOUS-REPLICATION)\n- [Bailis et al., Coordination Avoidance in Database Systems](https://www.vldb.org/pvldb/vol8/p185-bailis.pdf)\n- [Balegas et al., Extending Eventually Consistent Cloud Databases for Enforcing Numeric Invariants](https://arxiv.org/abs/1503.09052)\n- [Martin Kleppmann: How to do distributed locking](https://martin.kleppmann.com/2016/02/08/how-to-do-distributed-locking.html)\n- [Martin Fowler: The LMAX Architecture](https://martinfowler.com/articles/lmax.html)\n- [DynamoDB: utformning av partitionsnycklar](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-design.html)\n- [DynamoDB: partitioner och datafördelning](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/HowItWorks.Partitions.html)\n- [microservices.io: Saga](https://microservices.io/patterns/data/saga.html)\n- [microservices.io: Transactional outbox](https://microservices.io/patterns/data/transactional-outbox.html)\n- [Redis: replikering](https://redis.io/docs/latest/operate/oss_and_stack/management/replication/)\n- [Jepsen](https://jepsen.io/)\n\n\u003chttps://engineer.company/sv/notes/selling-limited-stock-without-overselling/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"En blixtrea översäljer på en enda het rad, inte på en stor databas. Det som stoppar det: en villkorad skrivning, reservationer som löper ut och en saga.","formats":{"gemtext":"https://data.engineer.company/sv/notes/selling-limited-stock-without-overselling/index.gmi","gopher":"https://data.engineer.company/sv/notes/selling-limited-stock-without-overselling/gophermap","html":"https://data.engineer.company/sv/notes/selling-limited-stock-without-overselling/","json":"https://data.engineer.company/sv/notes/selling-limited-stock-without-overselling/index.json","markdown":"https://data.engineer.company/sv/notes/selling-limited-stock-without-overselling/index.md","pdf":"https://data.engineer.company/sv/notes/selling-limited-stock-without-overselling/index.pdf"},"kind":"page","language":"sv","title":"Att sälja den sista biljetten exakt en gång","url":"https://data.engineer.company/sv/notes/selling-limited-stock-without-overselling/","version":1}