{"canonical_url":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/","content_markdown":"# At sælge den sidste billet præcis én gang\n\n2026-10-13\n\nEt flash-salg stiller ti tusind enheder foran en million mennesker på én gang.\nDen interessante fejl er ikke, at butikken går ned. Det er, at butikken bliver\noppe og sælger ti tusind og fyrre. Instinktet bagefter — databasen er for lille,\nså shard den — svarer på et spørgsmål, ingen har stillet. Databasen var aldrig\nfor stor. Alle købere skrev til\nden samme række *(hele hændelsen ligger i én række)*.\n\nVi skiller problemet ad her, før det rammer et projekt: hvor loftet kommer fra,\nden ene sætning, der fjerner det meste af det, og hvad man bygger, når én\ndatabase reelt ikke er nok.\n\n## Én række, alle købere\n\nTyve millioner rækker fordelt over en klynge er et løst problem. Én række, som\nhver eneste forespørgsel skal ændre, er ikke, og flere maskiner rører den ikke,\nfor rækken ligger på én af dem. Distribuerede lagre siger det ligeud: DynamoDB\ngiver én partition omkring 1.000 skriveenheder i sekundet, og hver skrivning til\nén vare lander på varens partition, uanset hvor mange andre der findes.\n\nDer ligger et teorem bag formen. Bailis og kolleger kalder en invariant\ninvariant-konfluent, når replikaer kan tage imod skrivninger hver for sig og\nstadig flettes til en gyldig tilstand. `stock \u003e= 0` er skoleeksemplet på én,\nder ikke er det: to replikaer, der hver ser én enhed tilbage, sælger den hver\nisær, og ingen fletning kan tage det andet salg tilbage. At aldrig oversælge\nkræver koordinering. Spørgsmålet er kun, hvor meget af den hvert salg betaler\nfor.\n\n## Tallet, der afgør det\n\nLoftet for én vare er groft sagt, hvor mange salg én lås bærer, divideret med\nhvor længe låsen holdes:\n\n```text\nmaks. salg/s pr. vare ≈ salg pr. lås ÷ låsens holdetid\n```\n\n| Hvad holder rækken        | Loft pr. række |\n| ------------------------- | -------------- |\n| Lås, kald så betaling     | ~2/s           |\n| Lås, kør så app-logik     | ~100–200/s     |\n| Én betinget `UPDATE`      | ~500–2.000/s   |\n| Batches af 100 pr. commit | ~50.000/s      |\n| Én skriver i hukommelsen  | ~100.000+/s    |\n\nDet er størrelsesordener, ikke benchmarks; hardwaren flytter dem. Det, den ikke\nflytter, er formen. Det meste af en kort lås er committen, der venter på, at\nloggen når disken, og derfor vinder batching med to størrelsesordener: hundrede\nsalg deler én flush.\n\nSå er der fire håndtag tilbage, og hvert design herunder trækker i ét af dem:\n\n1. **Hold låsen kortere** — én sætning, intet over netværket inde i den.\n2. **Gør mere pr. lås** — saml nedskrivningerne i batches.\n3. **Hav flere låse** — del lageret over flere nøgler.\n4. **Send færre forespørgsler til låsen** — afvis de fleste købere, før de\n   når frem.\n\nDet sidste betyder mere, end det lyder til. Med en million købere og ti tusind\nenheder skal 990.000 forespørgsler fejle. Afvisninger er det meste af\ntrafikken, så \"udsolgt\" skal være det billigste svar, systemet giver: et\nventeværelse foran salget, en port, der lukker omtrent lige så mange købere ind,\nsom der er enheder, et `sold_out`-flag, som CDN'et serverer uden at spørge\nnogen, og en hastighedsgrænse pr. konto.\n\n## Ret den ene database først\n\nDen version, der kryber af sted eller oversælger, ser som regel sådan ud:\n\n```sql\nBEGIN;\nSELECT available FROM inventory\n WHERE item_id = :item FOR UPDATE;\n-- applikationen tjekker tallet\n-- og kalder måske en betalingsudbyder\nUPDATE inventory SET available = :new\n WHERE item_id = :item;\nCOMMIT;\n```\n\nLåsen er rigtig. Det, den holdes hen over, er forkert: hvert millisekund,\napplikationen bruger mellem `SELECT` og `UPDATE`, er et millisekund, den næste\nkøber venter. Uden `FOR UPDATE` er det værre. To købere læser 1, begge skriver\n0, og én enhed er solgt to gange.\n\nRettelsen gør tjekket og nedskrivningen til én sætning:\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-- én række tilbage: reserveret. ingen: udsolgt.\n```\n\nI PostgreSQL på READ COMMITTED venter en anden køber, der når rækken, mens den\nførste holder den, og evaluerer så `WHERE`-betingelsen igen mod den række, den\nførste committede. Tog det salg den sidste enhed, fejler betingelsen, og den\nanden køber får ingen række tilbage — udsolgt — i stedet for et negativt tal. På\nREPEATABLE READ eller SERIALIZABLE får den anden køber i stedet en\nserialiseringsfejl, hvilket er sikkert, men gør konkurrence til genforsøg; READ\nCOMMITTED er det niveau, sætningen er skrevet til. MySQL's InnoDB når samme\nsvar, fordi en `UPDATE` dér læser den senest committede række på ethvert\nniveau. Tilføj også begrænsningen, så en fejl et andet sted fejler højlydt i\nstedet for at sælge lager, der ikke findes:\n\n```sql\nALTER TABLE inventory\n  ADD CONSTRAINT available_not_negative\n  CHECK (available \u003e= 0);\n```\n\nSå resten af arbejdet i den ene database, nogenlunde efter udbytte:\n\n- **Intet eksternt inde i transaktionen.** Intet betalingskald, ingen\n  HTTP-forespørgsel, ingen besked sendt. Det hører til før transaktionen eller\n  efter den.\n- **Rør den varme række sidst.** Indsæt ordren og alt andet først, så låsen på den række, som flere transaktioner konkurrerer om,\n  kun varer under den sidste sætning og committen.\n- **Ingen optimistisk låsning på en varm tæller.** En versionskolonne gør\n  konkurrence til genforsøg, og under et salg er genforsøgene belastningen.\n- **Server læsningerne fra et andet sted.** Produktsidens \"12 tilbage\" kan komme\n  fra en replika eller en cache, der er et sekund bagud. Kun salget behøver den\n  primære.\n- **Giv lageret sin egen database,** så et salg aldrig skal konkurrere med\n  kataloget om den samme disk.\n- **Pool forbindelserne.** Hundrede tusind købere bør være et par dusin\n  forbindelser gennem PgBouncer, ikke tusindvis af backends, der venter på én\n  lås.\n\nPladser har en anden form, fordi hver enhed er unik, og de vil have en anden\nsætning. Hver plads er en række, og en køber springer de rækker over, som en\nanden transaktion holder, i stedet for at vente på 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 udløbet reservation er simpelthen ledig igen, så der skal ingen oprydder til,\nfor at svaret er rigtigt. Og `now()` er databasens ur, så applikationsservere,\nhvis ure er uenige, ikke kan være uenige om, hvornår en reservation udløb.\n\nFor mange butikker er dette afsnit hele rettelsen. Gør det før alt herunder, for\nsharding er en dør, der kun går én vej: let at gå igennem, dyr at gå tilbage\nigennem.\n\n## Reservér først, betal bagefter\n\nEn køber, der tager den sidste enhed og så forlader kortformularen, har ikke\nkøbt den. Så et salg er ikke én skrivning, men et kort livsforløb:\n\n```text\nAVAILABLE → HELD, i minutter → SOLD\n                             → RELEASED\n```\n\n- **Reservationen har forespørgslens nøgle, ikke forsøgets.** Hvert checkout\n  bærer en idempotensnøgle, og reservationstabellen bærer\n  `UNIQUE (tenant_id, idempotency_key)`, så et gentaget klik får den\n  reservation, det allerede har, og ikke en enhed mere. En detalje i PostgreSQL\n  bider her: `INSERT ... ON CONFLICT DO NOTHING RETURNING id` returnerer intet,\n  når rækken fandtes i forvejen, så \"ingen række tilbage\" betyder \"slå den op\",\n  ikke \"fejlede\".\n- **Hver overgang er betinget.** At bekræfte et salg flytter en reservation fra\n  `held` til `sold` kun dér, hvor den stadig er `held`, og en frigivelse giver\n  kun lageret tilbage, hvis dens egen opdatering ændrede præcis én række. En\n  frigivelse, der kører to gange — timeouten og annullér-knappen, for eksempel\n  — giver enheden tilbage én gang.\n- **Reservationer udløber efter minutter.** Fem til ti er det almindelige.\n  Forlæng reservationen én gang, når betalingen starter, så et langsomt kort\n  ikke mister den enhed, det er ved at betale for.\n- **Begræns antallet af enheder pr. køber ved reservationen,** så én konto ikke\n  kan holde hele lageret, mens den tænker sig om.\n\nUnder det hele ligger én linje, den mest nyttige i designet:\n\n```text\navailable + held + sold = total\n```\n\nDen gælder efter hver transaktion, én forespørgsel tjekker den, og når den\nholder op med at gælde, har noget oversolgt eller tabt en enhed — før en kunde\nsiger det.\n\n## Når én database ikke er nok\n\nNogle gange er den reelt ikke det: mange lejere, mange salg på én gang, flere\nregioner. Den struktur, der skalerer, holder fast i én regel — hver vare har\npræcis én ejer af sit lager, en lagertjeneste, og intet andet bestemmer — og\nsharder den tjeneste efter `(tenant_id, item_id)`, så én vares skrivninger\naldrig spænder over to shards. De største lejere får deres egne celler, så deres\nsalg ikke kan sulte andres ud. Kun reservationen behøver at være synkron;\nalt efter den kan være en besked.\n\nTil den varme vare inde i en shard er der fire værktøjer, og hvert trækker i ét\naf håndtagene ovenfor.\n\n**En port foran.** En tæller i Redis, nedskrevet af et Lua-script, så tjek og\nnedskrivning er ét trin, lukker omtrent lige så mange købere ind, som der er\nenheder, og afviser alle andre på mikrosekunder. Den er ikke dommeren. Redis\nreplikerer asynkront, så efter en failover kan den nye primære have glemt nogle\nadgange og lukket lidt for mange ind. Databasens betingede `UPDATE` bestemmer\nstadig, og en afstemningsproces nulstiller porten ud fra databasens tal.\n\n**Del lageret.** Ti tusind enheder kan være hundrede spande med hundrede, hver\nsin række eller sin shard, med hver køber sendt til én: hundrede låse i stedet\nfor én. Idéen er gammel — O'Neils escrow-transaktioner fra 1986, så Barbará og\nGarcia-Molinas demarkationsprotokol, så Balegas og kollegers begrænsede tællere\n— og dens ene reelle pris er halen. En købers spand løber tør, mens andre stadig\nhar lager, så prøv enten en anden spand eller flyt resterne, og saml dem til én\nigen, når salget nærmer sig sin afslutning. Samme idé giver hver region sin egen\nkvote, så de fleste salg aldrig krydser et hav for at spørge.\n\n**Én skriver pr. vare.** Læg hver forespørgsel på en vare på én Kafka-partition,\nlæst af én forbruger, der holder tallet i hukommelsen og committer sine\nafgørelser i batches. Én tråd og ingen låse: LMAX-formen. Forespørgsler bærer et\nid, og skriveren smider én væk, den allerede har afgjort, for en kø leverer to\ngange.\n\n**Enheder som rækker.** Når enhederne er få og unikke — pladser, nummererede\nudgaver — så opret én række til hver på forhånd og gør krav på dem med\n`SKIP LOCKED` som ovenfor, eller hold enhedernes id'er i et Redis-sæt og tag én\nmed `SPOP`. Så er der ingen tæller tilbage at slås om.\n\n## Resten af checkout\n\nBetaling, ordre og kvittering er separate systemer, og ingen transaktion spænder\nover dem. Tofaset commit er lærebogens svar og det forkerte her: det blokerer,\nmens en deltager er langsom, det lægger rundture til den varmeste sti, og\nbetalingsudbydere deltager ikke i det. En saga klarer opgaven, en række lokale\ntrin, hver med et trin, der fortryder det:\n\n```text\n1. reservér lager        fortryd: frigiv reservationen\n2. afventende ordre      fortryd: annullér ordren\n3. forlæng reservationen (udløber af sig selv)\n4. autorisér betaling    fortryd: annullér den\n5. bekræft HELD → SOLD\n6. hæv betalingen\n```\n\nAt autorisere først og hæve sidst betyder, at en betaling, der kommer efter\nsin reservations udløb, annulleres i stedet for at refunderes: pengene flyttede\nsig aldrig. Hvert trin skriver sin besked i en outbox-tabel i samme transaktion\nsom den ændring, den melder, og change data capture udgiver den, så intet går\ntabt mellem gemt og sendt. Hver forbruger er idempotent, med ordren som nøgle.\nBeskeder kommer mindst én gang, og idempotens gør det til i praksis én gang.\n\nEn distribueret lås hører ingen steder hjemme her. Kleppmanns pointe er, at en\nlåseholder kan gå i stå forbi sin lejeperiode — en garbage collection, en\nvirtuel maskine, der hænger — og blive ved med at skrive, og kuren er et\nfencing-token, som lageret tjekker. Men et lager, der kan tjekke et token, kan\ntjekke `available \u003e= :qty`, og så har det aldrig haft brug for låsen.\n\n## Sæt varen på pause, oversælg den aldrig\n\nKonsistens og tilgængelighed vælges pr. spørgsmål, ikke pr. system. \"Må jeg\nsælge denne enhed?\" skal være konsistent: når ejeren af en vares lager ikke kan\nnås, holder den vare op med at sælge. Alt andet — kataloget, mærket med\n\"3 tilbage\", ordrehistorikken — kan forblive tilgængeligt og være en smule\nforældet.\n\nDet stilleste oversalg kommer fra en failover. Med asynkron replikering\nbekræfter en primær et salg og dør, før dens replika har det; replikaen\nforfremmes, salget er væk, og enheden sælges igen. Rettelsen er at gøre et salg\nholdbart på mere end én maskine, før det bekræftes: en synkron standby i\nPostgreSQL (`synchronous_commit` med `synchronous_standby_names`) eller et lager\nbygget på Raft. Det koster latens på hver commit, hvilket forlænger præcis den\nholdetid, loftet divideres med, og batching og porten køber den tilbage. Afgræns\nogså pausen: en shard, der fejler, skal stoppe varerne på den, ikke butikken.\n\n## Bevis det\n\nIntet af det her skal tages på tro, heller ikke vores.\n\n- **Hold øje med invarianten.** Kør `available + held + sold = total` efter en\n  tidsplan, tegn den, og alarmér ved enhver afvigelse. Nul oversalg er et\n  serviceniveaumål med en alarm, ikke et håb.\n- **Fremprovokér kapløbet.** Ti tusind samtidige købere til hundrede enheder, i\n  testsuiten, der kræver præcis hundrede solgte og intet tal under nul.\n- **Ødelæg ting under kapløbet.** Dræb den primære, kap netværket, sæt en proces\n  på pause — i Jepsens ånd — og tjek invarianten bagefter.\n- **Belastningstest afvisningerne.** Udsolgt-stien skal forblive hurtig, når den\n  er 99 procent af trafikken, og kanten skal kunne tage den.\n- **Saml målingerne på ét dashboard:** låseventetider, udløbne reservationer og\n  afstanden mellem portens tal og databasens.\n\n## I hvilken rækkefølge\n\n1. Mål først. `pg_stat_statements` og låseventetiderne siger, om den varme\n   række overhovedet er problemet.\n2. Gør skrivningen til én betinget sætning.\n3. Skær belastningen ned: et venteværelse, en port, et cachet \"udsolgt\".\n4. Giv lageret sin egen tjeneste og sin egen ejer.\n5. Shard efter `(tenant_id, item_id)`, og kun hvis de første fire ikke var nok.\n6. Tilføj en tilstand til varme varer, spande eller én skriver, til det salg, du\n   ved kommer.\n7. Regioner til sidst, med kvoter.\n\n## Hvad vi ville sige til den næste\n\n- **Sharding svarer på et andet spørgsmål.** Det spreder mange rækker, og et\n  oversolgt salg er én række. Find ud af, hvilken af delene du har, før du\n  bygger.\n- **Gør tjek og nedskrivning til én sætning.** Det meste af afstanden mellem\n  fint og oversolgt er tiden mellem at læse et tal og at skrive det.\n- **Det meste af trafikken er svaret nej.** Gør afvisning til det billigste,\n  systemet gør.\n- **Sæt på pause, før du oversælger.** En vare, der holder op med at sælge i\n  tredive sekunder, er en undskyldning. En vare, der er solgt to gange, er en\n  refusion, en supportkø og en kunde, der husker det.\n- **Skriv invarianten ned, og hold øje med den.** Den er én linje, og den er det\n  eneste, der siger, at designet virker i drift og ikke kun i review.\n\n## Kilder\n\n- [PostgreSQL: Read Committed-isolation](https://www.postgresql.org/docs/current/transaction-iso.html#XACT-READ-COMMITTED)\n- [PostgreSQL: `FOR UPDATE` og `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: design af partitionsnøgler](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-design.html)\n- [DynamoDB: partitioner og datafordeling](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/da/notes/selling-limited-stock-without-overselling/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Et flash-salg oversælger på én varm række, ikke på en for stor database. Det, der stopper det: en betinget skrivning, reservationer, der udløber, og en saga.","formats":{"gemtext":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/index.gmi","gopher":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/gophermap","html":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/","json":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/index.json","markdown":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/index.md","pdf":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/index.pdf"},"kind":"page","language":"da","title":"At sælge den sidste billet præcis én gang","url":"https://engineer.company/da/notes/selling-limited-stock-without-overselling/","version":1}