{"id":3138,"date":"2022-06-15T05:27:58","date_gmt":"2022-06-15T05:27:58","guid":{"rendered":"http:\/\/the-codest.localhost\/blog\/concurrency-in-java-part-1-introduction\/"},"modified":"2026-03-11T05:59:41","modified_gmt":"2026-03-11T05:59:41","slug":"samtidighed-i-java-del-1-introduktion","status":"publish","type":"post","link":"https:\/\/thecodest.co\/da\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"Samtidighed i Java del 1 - Introduktion"},"content":{"rendered":"

Generelt er den konventionelle programmeringstilgang sekventiel. Alt i et program sker et trin ad gangen.
Men faktisk er det parallelle den m\u00e5de, hele verden k\u00f8rer p\u00e5 - det er evnen til at udf\u00f8re mere end \u00e9n opgave samtidig.<\/p>\n\n\n\n

Tr\u00e5d vs. proces<\/h2>\n\n\n\n

At diskutere avancerede emner som samtidighed i Java<\/a><\/strong> eller multithreading, er vi n\u00f8dt til at aftale nogle f\u00e6lles definitioner for at v\u00e6re sikre p\u00e5, at vi er p\u00e5 samme side.<\/p>\n\n\n\n

Lad os starte med det grundl\u00e6ggende. I den ikke-sekventielle verden har vi to slags samtidighedsrepr\u00e6sentanter: processer og
tr\u00e5de. En proces er en instans af det program, der k\u00f8rer. Normalt er den isoleret fra andre processer.
Operativsystemet er ansvarligt for at tildele ressourcer til hver proces. Desuden fungerer det som en leder, der
planl\u00e6gger og kontrollerer dem.<\/p>\n\n\n\n

En tr\u00e5d er en slags proces, men p\u00e5 et lavere niveau, og derfor kaldes den ogs\u00e5 en let tr\u00e5d. Flere tr\u00e5de kan k\u00f8re i en
proces. Her fungerer programmet som en scheduler og en controller for tr\u00e5de. P\u00e5 denne m\u00e5de ser de enkelte programmer ud til at g\u00f8re
flere opgaver p\u00e5 samme tid.<\/p>\n\n\n\n

Den grundl\u00e6ggende forskel mellem tr\u00e5de og processer er isolationsniveauet. Processen har sit eget s\u00e6t af
ressourcer, mens tr\u00e5den deler data<\/a> med andre tr\u00e5de. Det kan virke som en fejlbeh\u00e6ftet tilgang, og det er det ogs\u00e5. For
Lad os nu ikke fokusere p\u00e5 det, da det ligger uden for rammerne af denne artikel.<\/p>\n\n\n\n

Processer, tr\u00e5de - ok ... Men hvad er egentlig samtidighed? Samtidighed betyder, at du kan udf\u00f8re flere opgaver p\u00e5 samme tid.
tid. Det betyder ikke, at de opgaver skal k\u00f8re samtidig - det er det, der er parallelisme. Concurrenc i Javay<\/strong> g\u00f8r det heller ikke
kr\u00e6ver, at du har flere CPU'er eller endda flere kerner. Det kan opn\u00e5s i et milj\u00f8 med \u00e9n kerne ved at udnytte
skift af kontekst.<\/p>\n\n\n\n

Et begreb, der er relateret til samtidighed, er multithreading. Det er en funktion i programmer, der g\u00f8r det muligt for dem at udf\u00f8re flere opgaver p\u00e5 \u00e9n gang. Ikke alle programmer bruger denne tilgang, men dem, der g\u00f8r, kan kaldes flertr\u00e5dede.<\/p>\n\n\n\n

Vi er n\u00e6sten klar til at g\u00e5 i gang, bare en definition mere. Asynkroni betyder, at et program udf\u00f8rer ikke-blokerende operationer.
Den p\u00e5begynder en opgave og forts\u00e6tter derefter med andre ting, mens den venter p\u00e5 svaret. N\u00e5r den f\u00e5r svaret, kan den reagere<\/a> til det.<\/p>\n\n\n\n

Alt det der jazz<\/h2>\n\n\n\n

Som standard vil hver Java-applikation<\/strong> k\u00f8rer i \u00e9n proces. I den proces er der en tr\u00e5d, der er relateret til main()<\/code> metode til
en applikation. Men som n\u00e6vnt er det muligt at udnytte mekanismerne i flere tr\u00e5de inden for en
program.<\/p>\n\n\n\n

Kan k\u00f8res<\/h3>\n\n\n\n

Tr\u00e5d<\/code> er en Java<\/strong> klasse, hvor magien sker. Dette er objektrepr\u00e6sentationen af den f\u00f8rn\u00e6vnte tr\u00e5d. Til
oprette din egen tr\u00e5d, kan du udvide Tr\u00e5d<\/code> klasse. Det er dog ikke en anbefalet tilgang. Tr\u00e5de<\/code> skal bruges som en mekanisme, der k\u00f8rer opgaven. Opgaver er dele af Kode<\/a> som vi \u00f8nsker at k\u00f8re i en samtidig tilstand. Vi kan definere dem ved hj\u00e6lp af Kan k\u00f8res<\/code> interface.<\/p>\n\n\n\n

Men nok teori, lad os bruge vores kode, hvor vores mund er.<\/p>\n\n\n\n

Problem<\/h3>\n\n\n\n

Lad os antage, at vi har et par arrays af tal. For hver matrix vil vi gerne vide, hvad summen af tallene i en matrix er. Lad os
Lad som om der er mange af den slags arrays, og hver af dem er relativt store. Under s\u00e5danne forhold vil vi g\u00f8re brug af samtidighed og summere hvert array som en separat opgave.<\/p>\n\n\n\n

int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10};\nint[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};\n\nRunnable task1 = () -> {\n    int sum = Arrays.stream(a1).sum();\n    System.out.println(\"1. Summen er: \" + sum);\n};\n\nRunnable task2 = () -> {\n    int sum = Arrays.stream(a2).sum();\n    System.out.println(\"2. Summen er: \" + sum);\n};\n\nRunnable task3 = () -> {\n    int sum = Arrays.stream(a3).sum();\n    System.out.println(\"3. Summen er: \" + sum);\n};\n\nnew Thread(task1).start();\nnew Thread(task2).start();\nnew Thread(task3).start();<\/code><\/pre>\n\n\n\n
Som du kan se i koden ovenfor Kan k\u00f8res<\/code> er en funktionel gr\u00e6nseflade. Den indeholder en enkelt abstrakt metode k\u00f8r()<\/code>
uden argumenter. Den Kan k\u00f8res<\/code> interface b\u00f8r implementeres af enhver klasse, hvis instanser er beregnet til at v\u00e6re
udf\u00f8rt af en tr\u00e5d.<\/p>\n\n\n\n
N\u00e5r du har defineret en opgave, kan du oprette en tr\u00e5d til at k\u00f8re den. Dette kan g\u00f8res via ny tr\u00e5d()<\/code> konstrukt\u00f8r, der
tager Kan k\u00f8res<\/code> som sit argument.<\/p>\n\n\n\n
Det sidste skridt er at start()<\/code> en nyoprettet tr\u00e5d. I den API<\/a> Der er ogs\u00e5 k\u00f8r()<\/code> metoder i Kan k\u00f8res<\/code> og i
Tr\u00e5d<\/code>. Men det er ikke en m\u00e5de at udnytte samtidighed p\u00e5 i Java. Et direkte kald til hver af disse metoder resulterer i
udf\u00f8re opgaven i den samme tr\u00e5d som main()<\/code> metoden k\u00f8rer.<\/p>\n\n\n\n
Tr\u00e5dpuljer og eksekutorer<\/h3>\n\n\n\n
N\u00e5r der er mange opgaver, er det ikke en god id\u00e9 at oprette en separat tr\u00e5d for hver enkelt. Oprettelse af en Tr\u00e5d<\/code> er en
tung operation, og det er langt bedre at genbruge eksisterende tr\u00e5de end at oprette nye.<\/p>\n\n\n\n
N\u00e5r et program opretter mange kortvarige tr\u00e5de, er det bedre at bruge en tr\u00e5dpulje. Tr\u00e5dpuljen indeholder et antal
klar til at k\u00f8re, men i \u00f8jeblikket ikke aktive tr\u00e5de. At give en Kan k\u00f8res<\/code> til puljen f\u00e5r en af tr\u00e5dene til at kalde
k\u00f8r()<\/code> metode af givet Kan k\u00f8res<\/code>. N\u00e5r en opgave er afsluttet, eksisterer tr\u00e5den stadig og er i en inaktiv tilstand.<\/p>\n\n\n\n
Okay, du har forst\u00e5et det - du foretr\u00e6kker tr\u00e5dpuljer i stedet for manuel oprettelse. Men hvordan kan du g\u00f8re brug af tr\u00e5dpuljer? Den Eksekutorer<\/code>
Klassen har en r\u00e6kke statiske fabriksmetoder til konstruktion af tr\u00e5dpuljer. For eksempel newCachedThredPool()<\/code> skaber
en pulje, hvor nye tr\u00e5de oprettes efter behov, og inaktive tr\u00e5de opbevares i 60 sekunder. I mods\u00e6tning hertil,
newFixedThreadPool()<\/code> indeholder et fast s\u00e6t af tr\u00e5de, hvor inaktive tr\u00e5de opbevares p\u00e5 ubestemt tid.<\/p>\n\n\n\n
Lad os se, hvordan det kan fungere i vores eksempel. Nu beh\u00f8ver vi ikke at oprette tr\u00e5de manuelt. I stedet skal vi oprette
Udf\u00f8rerService<\/code> som giver en pulje af tr\u00e5de. Derefter kan vi tildele opgaver til den. Det sidste trin er at lukke tr\u00e5den
pool for at undg\u00e5 hukommelsesl\u00e6kager. Resten af den tidligere kode forbliver den samme.<\/p>\n\n\n\n
ExecutorService executor = Executors.newCachedThreadPool();\n\nexecutor.submit(opgave1);\nexecutor.submit(opgave2);\nexecutor.submit(opgave3);\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Kan kaldes<\/h3>\n\n\n\n
Kan k\u00f8res<\/code> virker som en smart m\u00e5de at skabe samtidige opgaver p\u00e5, men den har en stor mangel. Den kan ikke returnere nogen
v\u00e6rdi. Desuden kan vi ikke afg\u00f8re, om en opgave er f\u00e6rdig eller ej. Vi ved heller ikke, om den er afsluttet.
normalt eller us\u00e6dvanligt. L\u00f8sningen p\u00e5 disse problemer er Kan kaldes<\/code>.<\/p>\n\n\n\n
Kan kaldes<\/code> svarer til Kan k\u00f8res<\/code> P\u00e5 en m\u00e5de omslutter den ogs\u00e5 asynkrone opgaver. Den st\u00f8rste forskel er, at den er i stand til at
returnere en v\u00e6rdi. Returv\u00e6rdien kan v\u00e6re af en hvilken som helst (ikke-primitiv) type, da Kan kaldes<\/code> interface er en parameteriseret type.
Kan kaldes<\/code> er en funktionel gr\u00e6nseflade, der har opkald()<\/code> metode, som kan kaste en Undtagelse<\/code>.<\/p>\n\n\n\n
Lad os nu se, hvordan vi kan udnytte Kan kaldes<\/code> i vores array-problem.<\/p>\n\n\n\n
int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10};\nint[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};\n\nCallable task1 = () -> Arrays.stream(a1).sum();\nCallable task2 = () -> Arrays.stream(a2).sum();\nCallable task3 = () -> Arrays.stream(a3).sum();\n\nExecutorService executor = Executors.newCachedThreadPool();\nFuture future1 = executor.submit(task1);\nFuture future2 = executor.submit(task2);\nFuture future3 = executor.submit(task3);\n\nSystem.out.println(\"1. Summen er: \" + future1.get());\nSystem.out.println(\"2. Summen er: \" + future2.get());\nSystem.out.println(\"3. Summen er: \" + future3.get());\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Okay, vi kan se, hvordan Kan kaldes<\/code> oprettes og sendes derefter til Udf\u00f8rerService<\/code>. Men hvad pokker er Fremtiden<\/code>?
Fremtiden<\/code> fungerer som en bro mellem tr\u00e5dene. Summen af hvert array produceres i en separat tr\u00e5d, og vi har brug for en m\u00e5de at
f\u00e5 disse resultater tilbage til main()<\/code>.<\/p>\n\n\n\n
For at hente resultatet fra Fremtiden<\/code> Vi er n\u00f8dt til at ringe get()<\/code> metode. Her kan der ske en af to ting. For det f\u00f8rste kan
resultatet af den beregning, der udf\u00f8res af Kan kaldes<\/code> er tilg\u00e6ngelig. S\u00e5 f\u00e5r vi det med det samme. For det andet er resultatet ikke
klar endnu. I det tilf\u00e6lde get()<\/code> metoden vil blokere, indtil resultatet er tilg\u00e6ngeligt.<\/p>\n\n\n\n
ComputableFuture<\/h3>\n\n\n\n
Problemet med Fremtiden<\/code> er, at det fungerer i 'push-paradigmet'. N\u00e5r man bruger Fremtiden<\/code> Du skal v\u00e6re som en chef, der
sp\u00f8rger konstant: \"Er din opgave f\u00e6rdig? Er den klar?\", indtil den giver et resultat. At handle under konstant pres er
dyrt. En langt bedre tilgang ville v\u00e6re at bestille Fremtiden<\/code> hvad den skal g\u00f8re, n\u00e5r den er klar med sin opgave. Desv\u00e6rre,
Fremtiden<\/code> kan ikke g\u00f8re det, men ComputableFuture<\/code> kan.<\/p>\n\n\n\n
ComputableFuture<\/code> arbejder i 'pull-paradigmet'. Vi kan fort\u00e6lle den, hvad den skal g\u00f8re med resultatet, n\u00e5r den er f\u00e6rdig med sine opgaver. Den
er et eksempel p\u00e5 en asynkron tilgang.<\/p>\n\n\n\n
ComputableFuture<\/code> fungerer perfekt med Kan k\u00f8res<\/code> men ikke med Kan kaldes<\/code>. I stedet er det muligt at levere en opgave til
ComputableFuture<\/code> i form af Leverand\u00f8r<\/code>.<\/p>\n\n\n\n
Lad os se, hvordan ovenst\u00e5ende h\u00e6nger sammen med vores problem.<\/p>\n\n\n\n
int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10};\nint[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};\n\nCompletableFuture.supplyAsync(() -> Arrays.stream(a1).sum())\n                .thenAccept(System.out::println);\n\nCompletableFuture.supplyAsync(() -> Arrays.stream(a2).sum())\n                .thenAccept(System.out::println);\n\nCompletableFuture.supplyAsync(() -> Arrays.stream(a3).sum())\n                .thenAccept(System.out::println);<\/code><\/pre>\n\n\n\n
Det f\u00f8rste, der sl\u00e5r dig, er, hvor meget kortere denne l\u00f8sning er. Desuden ser det ogs\u00e5 p\u00e6nt og ryddeligt ud.<\/p>\n\n\n\n
Opgave til Fuldst\u00e6ndigFremtid<\/code> kan leveres af supplyAsync()<\/code> metode, der tager Leverand\u00f8r<\/code> eller af runAsync()<\/code> at
tager Kan k\u00f8res<\/code>. Et tilbagekald - et stykke kode, der skal k\u00f8res, n\u00e5r opgaven er fuldf\u00f8rt - defineres af thenAccept()<\/code>
metode.<\/p>\n\n\n\n
Konklusioner<\/h2>\n\n\n\n
Java<\/strong> giver mange forskellige tilgange til samtidighed. I denne artikel har vi kun lige ber\u00f8rt emnet.<\/p>\n\n\n\n
Ikke desto mindre d\u00e6kkede vi det grundl\u00e6ggende i Tr\u00e5d<\/code>, Kan k\u00f8res<\/code>, Kan kaldes<\/code>og CallableFuture<\/code> hvilket er en god pointe
for yderligere unders\u00f8gelse af emnet.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
L\u00e6s f\u00f8rste del af vores blogserie om samtidighed i Java. I den f\u00f8lgende artikel vil vi se n\u00e6rmere p\u00e5 forskellene mellem tr\u00e5d og proces, tr\u00e5dpuljer, eksekutorer og meget mere!<\/p>","protected":false},"author":2,"featured_media":3139,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"inline_featured_image":false,"footnotes":""},"categories":[8],"tags":[],"class_list":["post-3138","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-software-development"],"acf":[],"yoast_head":"\nConcurrency in Java Part 1 - Introduction - The Codest<\/title>\n<meta name=\"description\" content=\"Read the first part of our blog series devoted to concurrency in Java.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/thecodest.co\/da\/blog\/samtidighed-i-java-del-1-introduktion\/\" \/>\n<meta property=\"og:locale\" content=\"da_DK\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Concurrency in Java Part 1 - Introduction\" \/>\n<meta property=\"og:description\" content=\"Read the first part of our blog series devoted to concurrency in Java.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/thecodest.co\/da\/blog\/samtidighed-i-java-del-1-introduktion\/\" \/>\n<meta property=\"og:site_name\" content=\"The Codest\" \/>\n<meta property=\"article:published_time\" content=\"2022-06-15T05:27:58+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2026-03-11T05:59:41+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png\" \/>\n\t<meta property=\"og:image:width\" content=\"960\" \/>\n\t<meta property=\"og:image:height\" content=\"540\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"thecodest\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"thecodest\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"6 minutter\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"},\"author\":{\"name\":\"thecodest\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/person\\\/7e3fe41dfa4f4e41a7baad4c6e0d4f76\"},\"headline\":\"Concurrency in Java Part 1 – Introduction\",\"datePublished\":\"2022-06-15T05:27:58+00:00\",\"dateModified\":\"2026-03-11T05:59:41+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"},\"wordCount\":1295,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\"},\"image\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"articleSection\":[\"Software Development\"],\"inLanguage\":\"da-DK\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\",\"url\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\",\"name\":\"Concurrency in Java Part 1 - Introduction - The Codest\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"datePublished\":\"2022-06-15T05:27:58+00:00\",\"dateModified\":\"2026-03-11T05:59:41+00:00\",\"description\":\"Read the first part of our blog series devoted to concurrency in Java.\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#breadcrumb\"},\"inLanguage\":\"da-DK\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"da-DK\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#primaryimage\",\"url\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"contentUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/05\\\/concurrency_in_java_part_1_-_introduction.png\",\"width\":960,\"height\":540},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/thecodest.co\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"Concurrency in Java Part 1 – Introduction\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#website\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"name\":\"The Codest\",\"description\":\"\",\"publisher\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/thecodest.co\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"da-DK\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"da-DK\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/logo\\\/image\\\/\",\"url\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/03\\\/thecodest-logo.svg\",\"contentUrl\":\"https:\\\/\\\/thecodest.co\\\/app\\\/uploads\\\/2024\\\/03\\\/thecodest-logo.svg\",\"width\":144,\"height\":36,\"caption\":\"The Codest\"},\"image\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/logo\\\/image\\\/\"},\"sameAs\":[\"https:\\\/\\\/pl.linkedin.com\\\/company\\\/codest\",\"https:\\\/\\\/clutch.co\\\/profile\\\/codest\"]},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/person\\\/7e3fe41dfa4f4e41a7baad4c6e0d4f76\",\"name\":\"thecodest\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"da-DK\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g\",\"caption\":\"thecodest\"},\"url\":\"https:\\\/\\\/thecodest.co\\\/da\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Samtidighed i Java del 1 - Introduktion - The Codest","description":"L\u00e6s f\u00f8rste del af vores blogserie om samtidighed i Java.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/thecodest.co\/da\/blog\/samtidighed-i-java-del-1-introduktion\/","og_locale":"da_DK","og_type":"article","og_title":"Concurrency in Java Part 1 - Introduction","og_description":"Read the first part of our blog series devoted to concurrency in Java.","og_url":"https:\/\/thecodest.co\/da\/blog\/samtidighed-i-java-del-1-introduktion\/","og_site_name":"The Codest","article_published_time":"2022-06-15T05:27:58+00:00","article_modified_time":"2026-03-11T05:59:41+00:00","og_image":[{"width":960,"height":540,"url":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","type":"image\/png"}],"author":"thecodest","twitter_card":"summary_large_image","twitter_misc":{"Written by":"thecodest","Est. reading time":"6 minutter"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#article","isPartOf":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"},"author":{"name":"thecodest","@id":"https:\/\/thecodest.co\/#\/schema\/person\/7e3fe41dfa4f4e41a7baad4c6e0d4f76"},"headline":"Concurrency in Java Part 1 – Introduction","datePublished":"2022-06-15T05:27:58+00:00","dateModified":"2026-03-11T05:59:41+00:00","mainEntityOfPage":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"},"wordCount":1295,"commentCount":0,"publisher":{"@id":"https:\/\/thecodest.co\/#organization"},"image":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage"},"thumbnailUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","articleSection":["Software Development"],"inLanguage":"da-DK","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/","url":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/","name":"Samtidighed i Java del 1 - Introduktion - The Codest","isPartOf":{"@id":"https:\/\/thecodest.co\/#website"},"primaryImageOfPage":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage"},"image":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage"},"thumbnailUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","datePublished":"2022-06-15T05:27:58+00:00","dateModified":"2026-03-11T05:59:41+00:00","description":"L\u00e6s f\u00f8rste del af vores blogserie om samtidighed i Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"da-DK","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"da-DK","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#primaryimage","url":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","contentUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/05\/concurrency_in_java_part_1_-_introduction.png","width":960,"height":540},{"@type":"BreadcrumbList","@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/thecodest.co\/"},{"@type":"ListItem","position":2,"name":"Concurrency in Java Part 1 – Introduction"}]},{"@type":"WebSite","@id":"https:\/\/thecodest.co\/#website","url":"https:\/\/thecodest.co\/","name":"Codest","description":"","publisher":{"@id":"https:\/\/thecodest.co\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/thecodest.co\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"da-DK"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"da-DK","@id":"https:\/\/thecodest.co\/#\/schema\/logo\/image\/","url":"https:\/\/thecodest.co\/app\/uploads\/2024\/03\/thecodest-logo.svg","contentUrl":"https:\/\/thecodest.co\/app\/uploads\/2024\/03\/thecodest-logo.svg","width":144,"height":36,"caption":"The Codest"},"image":{"@id":"https:\/\/thecodest.co\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/pl.linkedin.com\/company\/codest","https:\/\/clutch.co\/profile\/codest"]},{"@type":"Person","@id":"https:\/\/thecodest.co\/#\/schema\/person\/7e3fe41dfa4f4e41a7baad4c6e0d4f76","name":"thecodest","image":{"@type":"ImageObject","inLanguage":"da-DK","@id":"https:\/\/secure.gravatar.com\/avatar\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g","url":"https:\/\/secure.gravatar.com\/avatar\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/5dbfe6a1e8c86e432e8812759e34e6fe82ebac75119ae3237a6c1311fa19caf4?s=96&d=mm&r=g","caption":"thecodest"},"url":"https:\/\/thecodest.co\/da\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/da\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}