{"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":"samtidighet-i-java-del-1-introduksjon","status":"publish","type":"post","link":"https:\/\/thecodest.co\/nb\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"Samtidighet i Java Del 1 - Introduksjon"},"content":{"rendered":"

Generelt er den konvensjonelle programmeringstiln\u00e6rmingen sekvensiell. Alt i et program skjer ett steg om gangen.
Men faktisk er det parallellkj\u00f8ringen som styrer hele verden - det er evnen til \u00e5 utf\u00f8re mer enn \u00e9n oppgave samtidig.<\/p>\n\n\n\n

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

For \u00e5 diskutere avanserte emner som samtidighet i Java<\/a><\/strong> eller flertr\u00e5ding, m\u00e5 vi bli enige om noen felles definisjoner for \u00e5 v\u00e6re sikre p\u00e5 at vi er p\u00e5 samme side.<\/p>\n\n\n\n

La oss begynne med det grunnleggende. I den ikke-sekvensielle verdenen har vi to typer samtidighetsrepresentanter: prosesser og
tr\u00e5der. En prosess er en instans av programmet som kj\u00f8rer. Normalt er den isolert fra andre prosesser.
Operativsystemet er ansvarlig for \u00e5 tildele ressurser til hver prosess. I tillegg fungerer det som en dirigent som
planlegger og kontrollerer dem.<\/p>\n\n\n\n

En tr\u00e5d er en slags prosess, men p\u00e5 et lavere niv\u00e5, derfor kalles den ogs\u00e5 lett tr\u00e5d. Flere tr\u00e5der kan kj\u00f8re i \u00e9n
prosess. Her fungerer programmet som en planlegger og en kontroll\u00f8r for tr\u00e5der. P\u00e5 denne m\u00e5ten ser det ut til at de enkelte programmene gj\u00f8r
flere oppgaver samtidig.<\/p>\n\n\n\n

Den grunnleggende forskjellen mellom tr\u00e5der og prosesser er isolasjonsniv\u00e5et. Prosessen har sitt eget sett med
ressurser, mens tr\u00e5den deler data<\/a> med andre tr\u00e5der. Det kan virke som en feilkilde, og det er det ogs\u00e5. For
N\u00e5 skal vi ikke fokusere p\u00e5 det, for det ligger utenfor denne artikkelen.<\/p>\n\n\n\n

Prosesser, tr\u00e5der - ok ... Men hva er egentlig samtidighet? Samtidighet betyr at du kan utf\u00f8re flere oppgaver samtidig.
tid. Det betyr ikke at disse oppgavene m\u00e5 kj\u00f8res samtidig - det er det som er parallellisme. Concurrenc i Javay<\/strong> gj\u00f8r heller ikke
krever at du har flere CPU-er eller til og med flere kjerner. Det kan oppn\u00e5s i et enkeltkjernemilj\u00f8 ved \u00e5 utnytte
bytte av kontekst.<\/p>\n\n\n\n

Et begrep som er relatert til samtidighet, er multithreading. Dette er en egenskap ved programmer som gj\u00f8r at de kan utf\u00f8re flere oppgaver samtidig. Ikke alle programmer bruker denne tiln\u00e6rmingen, men de som gj\u00f8r det, kan kalles flertr\u00e5dede.<\/p>\n\n\n\n

Vi er nesten klare, bare \u00e9n definisjon til. Asynkronitet betyr at et program utf\u00f8rer ikke-blokkerende operasjoner.
Den setter i gang en oppgave og fortsetter med andre ting mens den venter p\u00e5 svar. 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-applikasjon<\/strong> kj\u00f8rer i \u00e9n prosess. I denne prosessen er det \u00e9n tr\u00e5d knyttet til main()<\/code> metode for
en applikasjon. Som nevnt er det imidlertid mulig \u00e5 utnytte mekanismene for flere tr\u00e5der i en og samme
program.<\/p>\n\n\n\n

Kj\u00f8rbar<\/h3>\n\n\n\n

Tr\u00e5d<\/code> er en Java<\/strong> klassen der magien skjer. Dette er objektrepresentasjonen av den tidligere nevnte tr\u00e5den. Til
lage din egen tr\u00e5d, kan du utvide Tr\u00e5d<\/code> klasse. Det er imidlertid ikke en anbefalt tiln\u00e6rming. Tr\u00e5der<\/code> skal brukes som en mekanisme som kj\u00f8rer oppgaven. Oppgaver er deler av kode<\/a> som vi \u00f8nsker \u00e5 kj\u00f8re i samtidig modus. Vi kan definere dem ved hjelp av Kj\u00f8rbar<\/code> grensesnitt.<\/p>\n\n\n\n

Men nok teori, la oss sette koden der vi snakker.<\/p>\n\n\n\n

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

Anta at vi har et par matriser med tall. For hver matrise \u00f8nsker vi \u00e5 vite summen av tallene i en matrise. La oss
Vi later som om det finnes mange slike matriser, og hver av dem er relativt store. Under slike forhold \u00f8nsker vi \u00e5 utnytte samtidighet og summere hver matrise som en separat oppgave.<\/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, 10, 10};\nint[] a3 = {3, 4, 3, 4, 3, 4, 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 av koden ovenfor Kj\u00f8rbar<\/code> er et funksjonelt grensesnitt. Det inneholder en enkelt abstrakt metode run()<\/code>
uten argumenter. Den Kj\u00f8rbar<\/code> grensesnittet b\u00f8r implementeres av alle klasser hvis instanser er ment \u00e5 v\u00e6re
utf\u00f8rt av en tr\u00e5d.<\/p>\n\n\n\n
N\u00e5r du har definert en oppgave, kan du opprette en tr\u00e5d for \u00e5 kj\u00f8re den. Dette kan gj\u00f8res via ny tr\u00e5d()<\/code> konstrukt\u00f8r som
tar Kj\u00f8rbar<\/code> som sitt argument.<\/p>\n\n\n\n
Det siste trinnet er \u00e5 start()<\/code> en nyopprettet tr\u00e5d. I API<\/a> det finnes ogs\u00e5 run()<\/code> metoder i Kj\u00f8rbar<\/code> og i
Tr\u00e5d<\/code>. Det er imidlertid ikke en m\u00e5te \u00e5 utnytte samtidighet p\u00e5 i Java. Et direkte anrop til hver av disse metodene resulterer i
utf\u00f8re oppgaven i samme tr\u00e5d som main()<\/code> metoden kj\u00f8rer.<\/p>\n\n\n\n
Tr\u00e5dpooler og eksekutorer<\/h3>\n\n\n\n
N\u00e5r det er mange oppgaver, er det ikke lurt \u00e5 opprette en egen tr\u00e5d for hver av dem. \u00c5 opprette en Tr\u00e5d<\/code> er en
tungvint operasjon, og det er langt bedre \u00e5 gjenbruke eksisterende tr\u00e5der enn \u00e5 opprette nye.<\/p>\n\n\n\n
N\u00e5r et program oppretter mange kortvarige tr\u00e5der, er det bedre \u00e5 bruke et tr\u00e5dbasseng. Tr\u00e5dbassenget inneholder et antall
som er klare til \u00e5 kj\u00f8re, men som for \u00f8yeblikket ikke er aktive. \u00c5 gi en Kj\u00f8rbar<\/code> til poolen f\u00f8rer til at en av tr\u00e5dene kaller
run()<\/code> metode for gitt Kj\u00f8rbar<\/code>. Etter at en oppgave er fullf\u00f8rt, eksisterer tr\u00e5den fortsatt og er i en inaktiv tilstand.<\/p>\n\n\n\n
Ok, du skj\u00f8nner det - du foretrekker tr\u00e5dpooler i stedet for manuell oppretting. Men hvordan kan du bruke tr\u00e5dbassenger? Det Eksekutorer<\/code>
klassen har en rekke statiske fabrikkmetoder for konstruksjon av tr\u00e5dpooler. For eksempel newCachedThredPool()<\/code> skaper
en pool der nye tr\u00e5der opprettes etter behov, og inaktive tr\u00e5der beholdes i 60 sekunder. I motsetning til dette,
newFixedThreadPool()<\/code> inneholder et fast sett med tr\u00e5der, der inaktive tr\u00e5der beholdes p\u00e5 ubestemt tid.<\/p>\n\n\n\n
La oss se hvordan det kan fungere i v\u00e5rt eksempel. N\u00e5 trenger vi ikke \u00e5 opprette tr\u00e5der manuelt. I stedet m\u00e5 vi opprette
ExecutorService<\/code> som gir en pool av tr\u00e5der. Deretter kan vi tildele oppgaver til den. Det siste trinnet er \u00e5 lukke tr\u00e5den
for \u00e5 unng\u00e5 minnelekkasjer. Resten av den forrige koden forblir den samme.<\/p>\n\n\n\n
ExecutorService executor = Executors.newCachedThreadPool();\n\nexecutor.submit(oppgave1);\nexecutor.submit(oppgave2);\nexecutor.submit(oppgave3);\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Kan kalles<\/h3>\n\n\n\n
Kj\u00f8rbar<\/code> virker som en smart m\u00e5te \u00e5 opprette samtidige oppgaver p\u00e5, men den har en stor svakhet. Den kan ikke returnere noen
verdi. Dessuten kan vi ikke avgj\u00f8re om en oppgave er ferdig eller ikke. Vi vet heller ikke om den er fullf\u00f8rt
normalt eller unntaksvis. L\u00f8sningen p\u00e5 disse problemene er Kan kalles<\/code>.<\/p>\n\n\n\n
Kan kalles<\/code> ligner p\u00e5 Kj\u00f8rbar<\/code> p\u00e5 en m\u00e5te ogs\u00e5 asynkrone oppgaver. Hovedforskjellen er at den er i stand til \u00e5
returnerer en verdi. Returverdien kan v\u00e6re av en hvilken som helst (ikke-primitiv) type, ettersom Kan kalles<\/code> grensesnittet er en parametrisert type.
Kan kalles<\/code> er et funksjonelt grensesnitt som har call()<\/code> metode som kan kaste en Unntak<\/code>.<\/p>\n\n\n\n
La oss n\u00e5 se hvordan vi kan utnytte Kan kalles<\/code> i matriseproblemet v\u00e5rt.<\/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, 10, 10};\nint[] a3 = {3, 4, 3, 4, 3, 4, 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
Ok, vi kan se hvordan Kan kalles<\/code> opprettes og sendes deretter til ExecutorService<\/code>. Men hva pokker er Fremtiden<\/code>?
Fremtiden<\/code> fungerer som en bro mellom tr\u00e5dene. Summen av hver matrise produseres i en separat tr\u00e5d, og vi trenger en m\u00e5te \u00e5
f\u00e5 disse resultatene tilbake til main()<\/code>.<\/p>\n\n\n\n
For \u00e5 hente resultatet fra Fremtiden<\/code> m\u00e5 vi ringe get()<\/code> metode. Her kan en av to ting skje. For det f\u00f8rste kan
resultatet av beregningen utf\u00f8rt av Kan kalles<\/code> er tilgjengelig. Da f\u00e5r vi det umiddelbart. For det andre er resultatet ikke
klar enn\u00e5. I s\u00e5 fall get()<\/code> metoden vil blokkere til resultatet er tilgjengelig.<\/p>\n\n\n\n
ComputableFuture<\/h3>\n\n\n\n
Problemet med Fremtiden<\/code> er at den fungerer i \"push-paradigmet\". N\u00e5r du bruker Fremtiden<\/code> m\u00e5 du v\u00e6re som en sjef som
sp\u00f8r hele tiden: \"Er oppgaven din ferdig? Er den klar?\" helt til den gir et resultat. \u00c5 handle under konstant press er
dyrt. En mye bedre tiln\u00e6rming ville v\u00e6re \u00e5 bestille Fremtiden<\/code> hva den skal gj\u00f8re n\u00e5r den er ferdig med oppgaven sin. Dessverre,
Fremtiden<\/code> kan ikke gj\u00f8re det, men ComputableFuture<\/code> kan.<\/p>\n\n\n\n
ComputableFuture<\/code> fungerer i \"pull-paradigmet\". Vi kan fortelle den hva den skal gj\u00f8re med resultatet n\u00e5r den er ferdig med oppgavene sine. Det
er et eksempel p\u00e5 en asynkron tiln\u00e6rming.<\/p>\n\n\n\n
ComputableFuture<\/code> fungerer perfekt med Kj\u00f8rbar<\/code> men ikke med Kan kalles<\/code>. I stedet er det mulig \u00e5 levere en oppgave til
ComputableFuture<\/code> i form av Leverand\u00f8r<\/code>.<\/p>\n\n\n\n
La oss se hvordan dette henger sammen med problemet v\u00e5rt.<\/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, 10, 10};\nint[] a3 = {3, 4, 3, 4, 3, 4, 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 som sl\u00e5r deg er hvor mye kortere denne l\u00f8sningen er. I tillegg ser det ogs\u00e5 pent og ryddig ut.<\/p>\n\n\n\n
Oppgave til CompletableFuture<\/code> kan leveres av supplyAsync()<\/code> metode som tar Leverand\u00f8r<\/code> eller av runAsync()<\/code> at
tar Kj\u00f8rbar<\/code>. En tilbakekalling - et stykke kode som skal kj\u00f8res n\u00e5r oppgaven er fullf\u00f8rt - defineres av thenAccept()<\/code>
metode.<\/p>\n\n\n\n
Konklusjoner<\/h2>\n\n\n\n
Java<\/strong> gir mange forskjellige tiln\u00e6rminger til samtidighet. I denne artikkelen har vi s\u00e5 vidt ber\u00f8rt temaet.<\/p>\n\n\n\n
Likevel har vi dekket det grunnleggende om Tr\u00e5d<\/code>, Kj\u00f8rbar<\/code>, Kan kalles<\/code>, og CallableFuture<\/code> noe som er et godt poeng
for videre utforskning av temaet.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
Les f\u00f8rste del av bloggserien v\u00e5r om samtidighet i Java. I den f\u00f8lgende artikkelen skal vi se n\u00e6rmere p\u00e5 forskjellene mellom tr\u00e5d og prosess, tr\u00e5dbassenger, eksekutorer og mye mer!<\/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\/nb\/blogg\/samtidighet-i-java-del-1-introduksjon\/\" \/>\n<meta property=\"og:locale\" content=\"nb_NO\" \/>\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\/nb\/blogg\/samtidighet-i-java-del-1-introduksjon\/\" \/>\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 minutes\" \/>\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\":\"nb-NO\",\"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\":\"nb-NO\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"nb-NO\",\"@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\":\"nb-NO\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"nb-NO\",\"@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\":\"nb-NO\",\"@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\\\/nb\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Samtidighet i Java del 1 - Introduksjon - The Codest","description":"Les f\u00f8rste del av bloggserien v\u00e5r om samtidighet 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\/nb\/blogg\/samtidighet-i-java-del-1-introduksjon\/","og_locale":"nb_NO","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\/nb\/blogg\/samtidighet-i-java-del-1-introduksjon\/","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 minutes"},"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":"nb-NO","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":"Samtidighet i Java del 1 - Introduksjon - 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":"Les f\u00f8rste del av bloggserien v\u00e5r om samtidighet i Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"nb-NO","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"nb-NO","@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":"nb-NO"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"The Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"nb-NO","@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":"nb-NO","@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\/nb\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/nb\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}