{"canonical_url":"https://engineer.company/nb/notes/selling-limited-stock-without-overselling/","content_markdown":"# Å selge den siste billetten nøyaktig én gang\n\n2026-10-13\n\nEt lynsalg setter ti tusen enheter foran en million mennesker samtidig. Den\ninteressante feilen er ikke at butikken går ned. Det er at butikken holder seg\noppe og selger ti tusen og førti. Instinktet som følger — databasen er for\nliten, shard den — svarer på et spørsmål ingen stilte. Databasen var aldri for\nstor. Hver kjøper skrev til\nden samme raden *(hele hendelsen bor i én rad)*.\n\nHer tar vi problemet fra hverandre før det når et prosjekt: hvor taket kommer\nfra, den ene setningen som fjerner det meste av det, og hva du bygger når én\ndatabase virkelig ikke er nok.\n\n## Én rad, alle kjøpere\n\nTjue millioner rader fordelt over en klynge er et løst problem. Én rad som hver\nforespørsel må endre, er det ikke, og flere maskiner endrer ingenting ved det,\nfordi raden bor på én av dem. Distribuerte datalagre sier det rett ut: DynamoDB\ngir én enkelt partisjon rundt 1 000 skriveenheter i sekundet, og hver skriving\ntil ett element havner på partisjonen til det elementet, uansett hvor mange\nandre det finnes.\n\nDet ligger et teorem bak denne formen. Bailis og kolleger kaller en invariant\ninvariant-konfluent når replikaer kan ta imot skrivinger på egen hånd og likevel\nflettes sammen til en gyldig tilstand. `stock \u003e= 0` er skoleeksempelet på en som\nikke er det: to replikaer som hver ser én enhet igjen, vil hver selge den, og\ningen fletting kan ta det andre salget tilbake. Å aldri overselge krever\nkoordinering. Det eneste spørsmålet er hvor mye av den hvert salg betaler for.\n\n## Tallet som avgjør det\n\nTaket for én vare er omtrent hvor mange salg én lås bærer, delt på hvor lenge\nlåsen holdes:\n\n```text\nmaks. salg/s per vare ≈ salg per lås ÷ låsens holdetid\n```\n\n| Hva som holder raden       | Tak per rad  |\n| -------------------------- | ------------ |\n| Lås, så kall til betaling  | ~2/s         |\n| Lås, så applikasjonslogikk | ~100–200/s   |\n| Én betinget `UPDATE`       | ~500–2 000/s |\n| Batcher på 100 per commit  | ~50 000/s    |\n| Én skriver i minnet        | ~100 000+/s  |\n\nDette er størrelsesordener, ikke ytelsesmålinger; maskinvaren flytter dem. Det\nden ikke flytter, er formen. Det meste av en kort lås er commiten som venter på\nat loggen skal nå disken, og det er derfor batching vinner med to\nstørrelsesordener: hundre salg deler én diskskriving.\n\nDet gir fire spaker, og hvert design nedenfor trekker i én av dem:\n\n1. **Hold låsen kortere** — én setning, ingenting over nettverket inne i den.\n2. **Gjør mer per lås** — samle nedtellingene i batcher.\n3. **Ha flere låser** — fordel beholdningen på flere nøkler.\n4. **Send færre forespørsler til låsen** — avvis de fleste kjøperne før de når\n   den.\n\nDen siste betyr mer enn den høres ut som. Med en million kjøpere og ti tusen\nenheter må 990 000 forespørsler mislykkes. Avvisninger er det meste av\ntrafikken, så «utsolgt» må være det billigste svaret systemet gir: et venterom\nforan salget, en port som slipper inn omtrent like mange kjøpere som det finnes\nenheter, et `sold_out`-flagg som CDN-et serverer uten å spørre noen, og en\nhastighetsbegrensning per konto.\n\n## Få den ene databasen i orden først\n\nVersjonen som går i sneglefart, eller som overselger, ser som regel slik ut:\n\n```sql\nBEGIN;\nSELECT available FROM inventory\n WHERE item_id = :item FOR UPDATE;\n-- applikasjonen sjekker tallet,\n-- og kaller kanskje en betalingsleverandør\nUPDATE inventory SET available = :new\n WHERE item_id = :item;\nCOMMIT;\n```\n\nLåsen er riktig. Det den holdes over, er feil: hvert millisekund applikasjonen\nbruker mellom `SELECT` og `UPDATE`, er et millisekund den neste kjøperen venter.\nUten `FOR UPDATE` er det verre. To kjøpere leser 1, begge skriver 0, og én enhet\ner solgt to ganger.\n\nLøsningen gjør sjekken og nedtellingen til én setning:\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 rad tilbake: reservert. ingen: utsolgt.\n```\n\nI PostgreSQL på READ COMMITTED venter en annen kjøper som når raden mens den\nførste holder den, og evaluerer så `WHERE`-leddet på nytt mot raden den første\nhar committet. Tok det salget den siste enheten, slår betingelsen feil, og den\nandre kjøperen får ingen rad tilbake — utsolgt — i stedet for et negativt tall.\nPå REPEATABLE READ eller SERIALIZABLE får den andre kjøperen i stedet en\nserialiseringsfeil, som er trygt, men gjør kampen om raden til nye forsøk; READ\nCOMMITTED er nivået denne setningen er skrevet for. InnoDB i MySQL kommer til\nsamme svar, fordi en `UPDATE` der leser den sist committede raden på alle nivåer.\nLegg også til begrensningen, slik at en feil et annet sted feiler høylytt i\nstedet for å selge beholdning som ikke finnes:\n\n```sql\nALTER TABLE inventory\n  ADD CONSTRAINT available_not_negative\n  CHECK (available \u003e= 0);\n```\n\nSå resten av arbeidet på den ene databasen, omtrent i rekkefølge etter gevinst:\n\n- **Ingenting eksternt inne i transaksjonen.** Ingen betalingskall, ingen\n  HTTP-forespørsel, ingen publisert melding. Det hører hjemme før transaksjonen\n  eller etter den.\n- **Rør den hete raden sist.** Sett inn ordren og alt annet først, slik at låsen\n  på raden som flere transaksjoner konkurrerer om, bare varer gjennom den siste\n  setningen og commiten.\n- **Ingen optimistisk låsing på en het teller.** En versjonskolonne gjør kampen\n  om raden til nye forsøk, og under et salg er det de nye forsøkene som er\n  lasten.\n- **Hent lesingene fra et annet sted.** «12 igjen» på produktsiden kan komme fra\n  en replika eller en hurtigbuffer som ligger et sekund etter. Bare salget\n  trenger primærnoden.\n- **Gi lagerbeholdningen en egen database,** slik at et salg aldri venter bak\n  katalogen på den samme disken.\n- **Samle tilkoblingene i en pool.** Hundre tusen kjøpere bør bli noen dusin\n  tilkoblinger gjennom PgBouncer, ikke tusenvis av databaseprosesser som venter\n  på én lås.\n\nSeter har en annen form, fordi hver enhet er unik, og de trenger en annen\nsetning. Hvert sete er en rad, og en kjøper hopper over radene en annen\ntransaksjon holder, i stedet for å vente bak 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 utløpt reservasjon er rett og slett ledig igjen, så det trengs ingen\noppryddingsjobb for at svaret skal bli riktig. Og `now()` er databasens klokke,\nså applikasjonsservere med klokker som ikke stemmer overens, kan ikke være\nuenige om når en reservasjon gikk ut.\n\nFor mange butikker er denne delen hele løsningen. Gjør den før noe av det som\nfølger, fordi sharding er en enveisdør: lett å gå gjennom, dyr å gå tilbake\ngjennom.\n\n## Reserver først, betal etterpå\n\nEn kjøper som tar den siste enheten og så forlater kortskjemaet, har ikke kjøpt\nden. Et salg er derfor ikke én skriving, men en kort livssyklus:\n\n```text\nAVAILABLE → HELD, i minutter → SOLD\n                             → RELEASED\n```\n\n- **Reservasjonen er knyttet til forespørselen, ikke til forsøket.** Hver\n  utsjekking har en idempotensnøkkel, og reservasjonstabellen har\n  `UNIQUE (tenant_id, idempotency_key)`, slik at et klikk som prøves på nytt, får\n  tilbake reservasjonen det allerede har, i stedet for en enhet til. Én\n  PostgreSQL-detalj biter her: `INSERT ... ON CONFLICT DO NOTHING RETURNING id`\n  returnerer ingenting når raden fantes fra før, så «ingen rad tilbake» betyr\n  «slå den opp», ikke «feilet».\n- **Hver overgang er betinget.** Å bekrefte et salg flytter en reservasjon fra\n  `held` til `sold` bare der den fortsatt er `held`, og en frigivelse fører\n  beholdningen tilbake bare hvis dens egen oppdatering endret nøyaktig én rad.\n  En frigivelse som kjører to ganger — tidsavbruddet og avbryt-knappen, for\n  eksempel — gir enheten tilbake én gang.\n- **Reservasjoner utløper etter minutter.** Fem til ti er vanlig. Forleng\n  reservasjonen én gang når betalingen starter, slik at et tregt kort ikke\n  mister enheten det betaler for.\n- **Sett et tak på enheter per kjøper ved reservasjonen,** slik at én konto ikke\n  kan holde hele beholdningen mens den bestemmer seg.\n\nUnder alt dette ligger én linje, den mest nyttige i hele designet:\n\n```text\navailable + held + sold = total\n```\n\nDen holder etter hver transaksjon, én spørring sjekker den, og når den slutter å\nholde, har noe oversolgt eller mistet en enhet — før en kunde sier fra.\n\n## Når én database ikke er nok\n\nNoen ganger er den virkelig ikke det: mange leietakere, mange salg samtidig,\nflere regioner. Strukturen som skalerer, holder fast ved én regel — hver vare\nhar nøyaktig én eier av beholdningen sin, en lagertjeneste, og ingenting annet\nbestemmer — og sharder den tjenesten etter `(tenant_id, item_id)`, slik at\nskrivingene for én vare aldri spenner over to shards. De største leietakerne får\negne celler, slik at salget deres ikke kan sulte ut noen andres. Bare\nreservasjonen må være synkron; alt etter den kan være en melding.\n\nFor den hete varen inne i en shard finnes det fire verktøy, og hvert av dem\ntrekker i én av spakene over.\n\n**En port foran.** En Redis-teller, som telles ned av et Lua-skript slik at\nsjekken og nedtellingen er ett steg, slipper inn omtrent like mange kjøpere som\ndet finnes enheter og avviser alle andre på mikrosekunder. Den er ikke\ndommeren. Redis replikerer asynkront, så etter en failover kan den nye\nprimærnoden ha glemt noen innslipp og latt noen for mange komme gjennom.\nDatabasens betingede `UPDATE` avgjør fortsatt, og en avstemmingsjobb nullstiller\nporten ut fra databasens tall.\n\n**Del opp beholdningen.** Ti tusen enheter kan være hundre bøtter med hundre,\nhver sin egen rad eller sin egen shard, og hver kjøper sendes til én av dem:\nhundre låser i stedet for én. Ideen er gammel — O'Neils escrow-transaksjoner i\n1986, så demarkasjonsprotokollen til Barbará og Garcia-Molina, så de begrensede\ntellerne til Balegas og kolleger — og den eneste reelle kostnaden er halen.\nBøtten til en kjøper går tom mens andre fortsatt har beholdning, så prøv enten\nen annen bøtte eller flytt restene, og slå dem sammen til én igjen mot slutten\nav et salg. Den samme ideen gir hver region en egen kvote, slik at de fleste\nsalg aldri krysser et hav for å spørre.\n\n**Én skriver per vare.** Legg hver forespørsel for en vare på én\nKafka-partisjon, lest av én konsument som holder tellingen i minnet og committer\nbeslutningene sine i batcher. Én tråd og ingen låser: LMAX-formen. Forespørsler\nhar en id, og skriveren forkaster en den allerede har avgjort, fordi en kø\nleverer to ganger.\n\n**Enheter som rader.** Når enhetene er få og unike — seter, nummererte utgaver —\nopprett én rad for hver på forhånd og reserver dem med `SKIP LOCKED` som over,\neller hold enhets-id-ene i et Redis-sett og hent én med `SPOP`. Da finnes det\ningen teller igjen å slåss om.\n\n## Resten av utsjekkingen\n\nBetaling, ordre og kvittering er separate systemer, og ingen transaksjon spenner\nover dem. Tofase-commit er læreboksvaret og feil svar her: den blokkerer så\nlenge en deltaker er treg, den legger rundturer til den heteste stien, og\nbetalingsleverandører deltar ikke i den. En saga gjør jobben, en rekke lokale\nsteg, hvert med et steg som angrer det:\n\n```text\n1. reserver beholdning     angre: frigi reservasjonen\n2. ventende ordre          angre: kanseller ordren\n3. forleng reservasjonen   (utløper av seg selv)\n4. autoriser betalingen    angre: annuller den\n5. bekreft HELD → SOLD\n6. trekk betalingen\n```\n\nÅ autorisere først og trekke sist betyr at en betaling som kommer etter at\nreservasjonen har utløpt, annulleres i stedet for å refunderes: pengene flyttet\nseg aldri. Hvert steg skriver meldingen sin til en outbox-tabell i den samme\ntransaksjonen som endringen den kunngjør, og change data capture publiserer\nden, så ingenting går tapt mellom lagret og sendt. Hver konsument er idempotent,\nmed ordren som nøkkel. Meldinger kommer minst én gang, og idempotens gjør det i\npraksis til én gang.\n\nEn distribuert lås hører ikke hjemme noe sted i dette. Kleppmanns poeng er at\nden som holder en lås, kan bli stående på pause forbi leieperioden sin — en\nsøppelinnsamling, en virtuell maskin som henger — og fortsette å skrive, og\nkuren er et fencing-token som datalageret sjekker. Men et datalager som kan\nsjekke et token, kan sjekke `available \u003e= :qty`, og da trengte det aldri låsen.\n\n## Sett varen på pause, overselg den aldri\n\nKonsistens og tilgjengelighet velges per spørsmål, ikke per system. «Kan jeg\nselge denne enheten?» må være konsistent: når eieren av en vares beholdning ikke\nkan nås, slutter den varen å selges. Alt annet — katalogen, «3 igjen»-merket,\nordrehistorikken — kan forbli tilgjengelig og være litt utdatert.\n\nDet stilleste oversalget kommer fra en failover. Med asynkron replikering\nbekrefter en primærnode et salg og dør før replikaen har fått det; replikaen\nforfremmes, salget er borte, og enheten selges på nytt. Løsningen er å gjøre et\nsalg varig på mer enn én maskin før det bekreftes: en synkron standby i\nPostgreSQL (`synchronous_commit` med `synchronous_standby_names`), eller et\ndatalager bygd på Raft. Det koster latens på hver commit, noe som forlenger\nnøyaktig den holdetiden for låsen som taket deles på, og batching og porten\nkjøper den tilbake. Avgrens pausen også: en shard som feiler, skal stoppe varene\npå den, ikke butikken.\n\n## Å bevise det\n\nIngenting av dette bør tas på tro, heller ikke vårt.\n\n- **Overvåk invarianten.** Kjør `available + held + sold = total` etter en\n  tidsplan, vis den i en graf og send varsel ved ethvert avvik. Null oversalg er\n  et tjenestenivåmål med en alarm, ikke et håp.\n- **Fremprovoser kappløpet med vilje.** Ti tusen samtidige kjøpere til hundre\n  enheter, i testsuiten, med automatiske kontroller av at nøyaktig hundre er solgt og at\n  ingen tall er under null.\n- **Ødelegg ting under kappløpet.** Drep primærnoden, kutt nettverket, sett en\n  prosess på pause — i Jepsen-stil — og sjekk invarianten etterpå.\n- **Lasttest avvisningene.** Utsolgt-stien må holde seg rask når den er 99 % av\n  trafikken, og kanten må ta imot den.\n- **Samle målingene på ett dashbord:** låseventing, utløpte reservasjoner og\n  avstanden mellom portens telling og databasens.\n\n## I hvilken rekkefølge\n\n1. Mål først. `pg_stat_statements` og låseventingen sier om den hete raden i\n   det hele tatt er problemet.\n2. Gjør skrivingen til én betinget setning.\n3. Kvitt deg med last: et venterom, en port, et hurtigbufret «utsolgt».\n4. Gi lagerbeholdningen sin egen tjeneste og sin egen eier.\n5. Shard etter `(tenant_id, item_id)`, og bare hvis de fire første ikke var nok.\n6. Legg til en modus for hete varer, bøtter eller én enkelt skriver, for salget\n   du vet kommer.\n7. Regioner til slutt, med kvoter.\n\n## Det vi ville sagt til den neste\n\n- **Sharding svarer på et annet spørsmål.** Den fordeler mange rader, og et\n  oversolgt salg er én rad. Finn ut hvilket av dem du har, før du bygger.\n- **Gjør sjekken og nedtellingen til én setning.** Det meste av avstanden mellom\n  i orden og oversolgt er tiden mellom å lese et tall og å skrive det.\n- **Det meste av trafikken er svaret nei.** Gjør avvisning til det billigste\n  systemet gjør.\n- **Sett på pause før du overselger.** En vare som slutter å selges i tretti\n  sekunder, er en unnskyldning. En vare som er solgt to ganger, er en refusjon,\n  en supportkø og en kunde som husker det.\n- **Skriv ned invarianten og overvåk den.** Den er én linje, og den er det\n  eneste som sier at designet virker i produksjon og ikke bare i gjennomgangen.\n\n## Kilder\n\n- [PostgreSQL: isolasjonsnivået Read Committed](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: utforming av partisjonsnøkler](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-partition-key-design.html)\n- [DynamoDB: partisjoner 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/nb/notes/selling-limited-stock-without-overselling/\u003e\n","date_modified":"2026-11-12T05:34:23Z","description":"Et lynsalg overselger på én het rad, ikke på en stor database. Det som stopper det: en betinget skriving, reservasjoner som utløper, og en saga.","formats":{"gemtext":"https://software.engineer.company/nb/notes/selling-limited-stock-without-overselling/index.gmi","gopher":"https://software.engineer.company/nb/notes/selling-limited-stock-without-overselling/gophermap","html":"https://software.engineer.company/nb/notes/selling-limited-stock-without-overselling/","json":"https://software.engineer.company/nb/notes/selling-limited-stock-without-overselling/index.json","markdown":"https://software.engineer.company/nb/notes/selling-limited-stock-without-overselling/index.md","pdf":"https://software.engineer.company/nb/notes/selling-limited-stock-without-overselling/index.pdf"},"kind":"page","language":"nb","title":"Å selge den siste billetten nøyaktig én gang","url":"https://software.engineer.company/nb/notes/selling-limited-stock-without-overselling/","version":1}