{"canonical_url":"https://engineer.company/da/glossary/queue/","content_markdown":"# Kø\n\n## Hvad det er\n\nEn kø er et mellemlager mellem to programmer: den ene side lægger beskeder eller\njobs ind, den anden tager dem ud, når den er klar, som regel de ældste først.\nNæsten ethvert system har flere køer, én pr. slags arbejde, og i køen ligger det\narbejde, der endnu venter på at blive taget. Programmet, der lægger arbejde ind,\nkaldes producenten, programmet, der tager det, kaldes forbrugeren, og det, der\nopbevarer beskederne imellem, kaldes en broker. Brokeren kan være en selvstændig\nserver eller en tabel i en database, systemet allerede har.\n\nPointen er, at de to sider holder op med at vente på hinanden. En webrequest,\nder skal have sendt en mail, lægger en besked i køen og svarer brugeren med det\nsamme; en worker henter beskeden et øjeblik senere, og kommer der hundrede på én\ngang, arbejder den sig igennem dem i sit eget tempo. Et spidsbelastningsøjeblik\nbliver til et efterslæb, og en afhængighed bliver til en forsinkelse.\n\nTo begreber beskriver, hvad en kø lover om levering. Det første er kvittering:\nforbrugeren melder tilbage til brokeren, når den er færdig med en besked, og\nførst da fjernes beskeden. I AMQP 0-9-1-modellen, som RabbitMQ bygger på, går en\nbesked videre til en anden forbruger, hvis den første dør uden at kvittere. Det\nandet er holdbarhed: en holdbar kø med persistente beskeder overlever, at\nbrokeren genstarter, mens en kø, der kun findes i hukommelsen, glemmer alt.\n\nTre beslægtede begreber er værd at holde adskilt. En beskedkø bærer data mellem\ntjenester. En jobkø bærer arbejdsopgaver til baggrunds-workers, hver med sine\nargumenter, en tilstand og et antal forsøg. En log, den model Apache Kafka\nbygger på, ligner en kø udefra, men beholder hændelserne, efter at de er læst,\ni en opbevaringsperiode, der vælges pr. topic, så flere læsere kan gennemgå den\nsamme historik. At læse fra en kø fjerner beskeden; at læse fra en log flytter\nkun læserens position.\n\nEn kø behøver ikke være et selvstændigt produkt. PostgreSQL kan løfte opgaven\nmed en tabel af jobs og en SQL-forespørgsel, der tager den næste række og\nspringer over rækker, en anden worker allerede har låst. Manualen nævner netop\nkølignende tabeller som grunden til, at `SKIP LOCKED` findes:\n\n```sql\nWITH next AS (\n  SELECT id\n    FROM jobs\n   WHERE state = 'available'\n   ORDER BY id\n   LIMIT 1\n     FOR UPDATE SKIP LOCKED\n)\nUPDATE jobs\n   SET state = 'running',\n       attempt = attempt + 1\n  FROM next\n WHERE jobs.id = next.id\nRETURNING jobs.id, jobs.args;\n```\n\n## Hvorfor det betyder noget\n\nKøen afgør, hvad brugeren venter på. Arbejde, der lægges i kø, sker efter at\nsvaret er sendt, så en side, der udløser en mail, en PDF, en genopbygning af et\nsøgeindeks og en genberegning, kan svare på den tid, det tager at skrive fire\nrækker. De fire langsomme opgaver bliver færdige bagefter. For en køber er det\nforskellen på et checkout, der svarer på få hundrede millisekunder, og et, der\nsvarer, når mailserveren har tid.\n\nKøen afgør også, hvad der overlever en fejl. Arbejde, der er startet i en\nbaggrundstråd, findes kun i processens hukommelse, og en udrulning, der\ngenstarter processen, tager arbejdet med sig uden at efterlade spor. Arbejde i\nen holdbar kø er derimod en optegnelse: det kan prøves igen, undersøges og\ntælles.\n\nOg køen adskiller to hastigheder. Producenter bevæger sig i takt med den\nindkommende trafik, forbrugere i takt med den langsomste tjeneste, de kalder.\nKøen imellem dem opsuger forskellen, og dens dybde bliver et af de ærligste tal,\net system kan melde. En kø, der er vokset i en time, fortæller, at forbrugerne\nsakker bagud, uanset hvad processorgrafen viser.\n\nFordelene har en pris. Arbejdet ligger nu uden for synsfeltet mellem at blive\nsendt og at blive gjort. Levering sker næsten altid mindst én gang, så en\nforbruger skal kunne tåle at se den samme besked to gange. Rækkefølgen er\nsvagere, end den ser ud. Og en selvstændig broker er endnu en server, der skal\ndrives, sikres, overvåges og opgraderes.\n\n## Sådan ser det ud i praksis\n\nMail, et søgeindeks, der skal genopbygges, dokumenter og genberegnede\nplaceringer er alt sammen arbejde, en bruger ikke bør vente på, og én platform\nflyttede det væk fra request-stien. Arbejde, der gives til en goroutine,\nforsvinder, når processen genstarter midt i en deploy, så\n[arbejdet kom over i en River-jobkø i PostgreSQL](/da/portfolio/moved-slow-work-onto-a-river-job-queue/).\nDatabasen var i forvejen det autoritative register, så at lægge et job i kø\nbliver en del af den samme transaktion som de data, jobbet handler om. Platformen\nfik nye forsøg og en historik, man kan slå op i; den erklærede grænse er, at en\nkø i databasen ikke skalerer i det uendelige.\n\nI et macOS-program bygget oven på et C-bibliotek var køen der for at holde\nrækkefølgen. Bibliotekets blokerende hændelsesløkke sender hændelser i en\nrækkefølge, der betyder noget, for en redigering skal ankomme efter den besked,\nden redigerer. At starte én opgave pr. hændelse lader køretiden planlægge dem i\nvilkårlig rækkefølge, så en redigering kan overhale sin egen besked. Den løsning,\nder blev valgt, har\n[én producenttråd, én forbruger og én kø imellem dem](/da/portfolio/adopted-swift-6-strict-concurrency-over-c/)\nog derefter et enkelt hop over på hovedaktøren. Rækkefølgen holder, fordi der\nkun er én vej. Prisen er parallelitet: alle hændelser går gennem den ene\nforbruger.\n\nEn kø kan også gøre skade. I en macOS-applikation blev en byge af\ncore-loghændelser beholdt i en ubegrænset hovedstrøm og kopieret til\nabonnenter, hvis forbrugere ikke brugte de hændelser. Diagnoserapporter\nregistrerede 111 GB komprimerede sider på en maskine med 36 GB; en\nseparat måling af hukommelsesforbruget registrerede en vækst på omkring\n41 MB i sekundet under en løkke med gentagne forbindelsesforsøg.\n[Hændelsesvejen fik udtrykkelige grænser](/da/portfolio/an-app-that-ate-41-mb-a-second-stopped/),\nmed abonnementer filtreret efter hændelsestype og en udtrykkelig politik\nfor bufferoverløb. Gentagne diagnostiske hændelser kan kasseres, og den\nberørte tilstand genindlæses i stedet for at beholde ubegrænset mange\nhændelser. Arkitekturkontroller og tests af applikationens budgetter\nunderstøtter det design, men beskrivelsen fastslår ikke et målt\nhukommelsesforbrug efter rettelsen eller et benchmark fra produktion.\n\n## Hvor det går galt\n\nProblemer med køer viser sig sent og et andet sted, fordi arbejdet med vilje\nligger uden for synsfeltet.\n\n**Efterslæbet vokser, til hukommelse eller disk slipper op.** En kø uden grænse\ntager imod arbejde hurtigere, end det bliver gjort, og gemmer forskellen. Giv\nhver kø en største længde, og beslut på forhånd, hvad der sker ved den: brems\nproducenten, afvis nyt arbejde, eller smid det ældste væk. Hold derefter øje med\nto tal, dybden og alderen på den ældste besked, for en kort kø af meget gamle\nbeskeder er lige så slem som en lang.\n\n**Den samme besked behandles to gange.** En forbruger gør arbejdet færdigt og dør,\nfør den kvitterer; brokeren leverer, helt korrekt, beskeden igen. RabbitMQ's\ndokumentation beder forbrugere om at regne med genlevering og om at være skrevet\nmed idempotens for øje. Giv hver besked et id, og registrér de id'er, der\nallerede er behandlet, i samme transaktion som selve arbejdet. En note på dette\nsite om\n[at sælge et begrænset lager uden at oversælge](/da/notes/selling-limited-stock-without-overselling/)\nbygger sin skriver på præcis den antagelse.\n\n**Beskederne ankommer i en anden rækkefølge, end de blev sendt i.** Parallelle\nforbrugere, forudhentning og nye forsøg, der stiller en fejlet besked bag nyere,\nbytter alle om på arbejdet. Når rækkefølgen betyder noget, så send alt om én\nkonto eller én ordre gennem den samme partition eller den samme forbruger. Kafka\ngør det efter nøgle, til den pris, at én travl nøgle kun går så hurtigt som én\nforbruger.\n\n**Én dårlig besked blokerer eller kører i ring.** En besked, hvis indhold får\nforbrugeren til at gå ned hver gang, lægges tilbage, leveres igen og får den til\nat gå ned igen. Sæt loft over antallet af forsøg, og flyt en besked, der har\nbrugt dem alle, over et separat sted, hvor et menneske kan se på den. RabbitMQ\nkalder det dead-lettering og bruger det på afviste beskeder, udløbne beskeder og\nbeskeder, der ville sprænge en længdegrænse.\n\n**Arbejdet forsvinder ved genstart.** En kanal, en liste i hukommelsen eller en\nbaggrundstråd er en kø, der intet beholder hen over en genstart. I AMQP er en\nholdbar kø heller ikke nok alene: beskederne skal også sendes som persistente.\nAfgør for hver slags arbejde, om det er acceptabelt at miste det.\n\n**Databasen og køen er uenige.** En tjeneste skriver en række, sender derefter\nen besked og går ned mellem de to; nu findes det ene uden det andet. Hold enten\nkøen i den samme database, så et job først bliver synligt for workers, når dets\ntransaktion committer, sådan som River gør, eller skriv beskeden i en\noutbox-tabel i samme transaktion og send den derfra.\n\n## Læs mere\n\n- [AMQP 0-9-1 Model Explained](https://www.rabbitmq.com/tutorials/amqp-concepts)\n  — exchanges, køer, bindinger og kvitteringer, forklaret af RabbitMQ.\n- [Consumer Acknowledgements and Publisher Confirms](https://www.rabbitmq.com/docs/confirms)\n  — hvornår en broker anser en besked for leveret, og hvorfor den leveres igen.\n- [Dead Letter Exchanges](https://www.rabbitmq.com/docs/dlx) — de betingelser,\n  der flytter en besked til side, og hvor den havner.\n- [The Locking Clause of SELECT](https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE)\n  — `FOR UPDATE` og `SKIP LOCKED` og de kølignende tabeller, de passer til.\n- [River: Getting started](https://riverqueue.com/docs) — en jobkø, der gemmer\n  sine jobs i programmets egen database.\n- [Apache Kafka: Introduction](https://kafka.apache.org/41/getting-started/introduction/)\n  — topics, partitioner og opbevaring i log-modellen.\n\n\u003chttps://engineer.company/da/glossary/queue/\u003e\n","date_modified":"2026-11-08T02:22:23Z","description":"Hvordan en kø flytter arbejde mellem programmer, hvad kvitteringer og nye forsøg lover, hvornår en databasetabel er nok, og seks måder køer svigter på.","formats":{"gemtext":"https://engineer.company/da/glossary/queue/index.gmi","gopher":"https://engineer.company/da/glossary/queue/gophermap","html":"https://engineer.company/da/glossary/queue/","json":"https://engineer.company/da/glossary/queue/index.json","markdown":"https://engineer.company/da/glossary/queue/index.md","pdf":"https://engineer.company/da/glossary/queue/index.pdf"},"kind":"page","language":"da","title":"Hvad er en kø?","url":"https://engineer.company/da/glossary/queue/","version":1}