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

I allm\u00e4nhet \u00e4r den konventionella programmeringsmetoden sekventiell. Allt i ett program sker ett steg i taget.
Men i sj\u00e4lva verket \u00e4r det parallellt som hela v\u00e4rlden fungerar - det \u00e4r f\u00f6rm\u00e5gan att utf\u00f6ra mer \u00e4n en uppgift samtidigt.<\/p>\n\n\n\n

Tr\u00e5d kontra process<\/h2>\n\n\n\n

F\u00f6r att diskutera avancerade \u00e4mnen som samtidighet i Java<\/a><\/strong> eller multithreading m\u00e5ste vi enas om n\u00e5gra gemensamma definitioner f\u00f6r att vara s\u00e4kra p\u00e5 att vi \u00e4r p\u00e5 samma sida.<\/p>\n\n\n\n

L\u00e5t oss b\u00f6rja med grunderna. I den icke-sekventiella v\u00e4rlden har vi tv\u00e5 typer av samtidighetsrepresentanter: processer och
tr\u00e5dar. En process \u00e4r en instans av det program som k\u00f6rs. Normalt sett \u00e4r den isolerad fr\u00e5n andra processer.
Operativsystemet ansvarar f\u00f6r att tilldela resurser till varje process. Dessutom fungerar det som en ledare som
schemal\u00e4gger och kontrollerar dem.<\/p>\n\n\n\n

Thread \u00e4r en slags process men p\u00e5 en l\u00e4gre niv\u00e5, d\u00e4rf\u00f6r kallas den ocks\u00e5 f\u00f6r light thread. Flera tr\u00e5dar kan k\u00f6ras i en
process. H\u00e4r fungerar programmet som en schemal\u00e4ggare och en styrenhet f\u00f6r tr\u00e5dar. P\u00e5 s\u00e5 s\u00e4tt verkar enskilda program g\u00f6ra
flera uppgifter p\u00e5 samma g\u00e5ng.<\/p>\n\n\n\n

Den grundl\u00e4ggande skillnaden mellan tr\u00e5dar och processer \u00e4r isoleringsniv\u00e5n. Processen har sin egen upps\u00e4ttning av
resurser, medan tr\u00e5den delar data<\/a> med andra tr\u00e5dar. Det kan tyckas vara en felben\u00e4gen metod och det \u00e4r det verkligen. F\u00f6r
men l\u00e5t oss inte fokusera p\u00e5 det eftersom det ligger utanf\u00f6r ramen f\u00f6r den h\u00e4r artikeln.<\/p>\n\n\n\n

Processer, tr\u00e5dar - okej... Men vad \u00e4r egentligen samtidighet? Concurrency inneb\u00e4r att du kan utf\u00f6ra flera uppgifter samtidigt
tid. Det betyder inte att dessa uppgifter m\u00e5ste k\u00f6ras samtidigt - det \u00e4r det som \u00e4r parallellism. Concurrenc i Javay<\/strong> g\u00f6r inte heller
kr\u00e4ver att du har flera processorer eller till och med flera k\u00e4rnor. Det kan uppn\u00e5s i en enk\u00e4rnig milj\u00f6 genom att utnyttja
byte av sammanhang.<\/p>\n\n\n\n

En term som \u00e4r relaterad till concurrency \u00e4r multithreading. Detta \u00e4r en funktion i program som g\u00f6r att de kan utf\u00f6ra flera uppgifter samtidigt. Det \u00e4r inte alla program som anv\u00e4nder detta tillv\u00e4gag\u00e5ngss\u00e4tt, men de som g\u00f6r det kan kallas flertr\u00e5dade.<\/p>\n\n\n\n

Vi \u00e4r n\u00e4stan klara, bara en definition till. Asynkroni inneb\u00e4r att ett program utf\u00f6r icke-blockerande operationer.
Den initierar en uppgift och forts\u00e4tter sedan med andra saker i v\u00e4ntan p\u00e5 svaret. N\u00e4r den f\u00e5r svaret kan den reagera<\/a> till det.<\/p>\n\n\n\n

All den d\u00e4r jazzen<\/h2>\n\n\n\n

Som standard \u00e4r varje Java-applikation<\/strong> k\u00f6rs i en process. I den processen finns det en tr\u00e5d som \u00e4r relaterad till main()<\/code> metod f\u00f6r
en applikation. Som n\u00e4mnts \u00e4r det dock m\u00f6jligt att utnyttja mekanismerna f\u00f6r flera tr\u00e5dar inom en
program.<\/p>\n\n\n\n

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

Tr\u00e5d<\/code> \u00e4r en Java<\/strong> klass d\u00e4r magin sker. Detta \u00e4r objektrepresentationen av den tidigare n\u00e4mnda tr\u00e5den. Till
skapa din egen tr\u00e5d kan du ut\u00f6ka Tr\u00e5d<\/code> klass. Det \u00e4r dock inte ett rekommenderat tillv\u00e4gag\u00e5ngss\u00e4tt. Tr\u00e5dar<\/code> b\u00f6r anv\u00e4ndas som en mekanism f\u00f6r att k\u00f6ra uppgiften. Uppgifter \u00e4r delar av kod<\/a> som vi vill k\u00f6ra i ett parallellt l\u00e4ge. Vi kan definiera dem med hj\u00e4lp av Kan k\u00f6ras<\/code> gr\u00e4nssnitt.<\/p>\n\n\n\n

Men nog med teori, l\u00e5t oss s\u00e4tta v\u00e5r kod d\u00e4r v\u00e5r mun \u00e4r.<\/p>\n\n\n\n

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

Anta att vi har ett par matriser med siffror. F\u00f6r varje matris vill vi veta summan av siffrorna i en matris. L\u00e5t oss
L\u00e5tsas att det finns m\u00e5nga s\u00e5dana matriser och att var och en av dem \u00e4r relativt stor. Under s\u00e5dana f\u00f6rh\u00e5llanden vill vi utnyttja samtidighet och summera varje matris som en separat uppgift.<\/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};\nint[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};\n\nK\u00f6rbar uppgift1 = () -> {\n    int sum = Arrays.stream(a1).sum();\n    System.out.println(\"1. Summan \u00e4r: \" + sum);\n};\n\nK\u00f6rbar uppgift2 = () -> {\n    int sum = Arrays.stream(a2).sum();\n    System.out.println(\"2. Summan \u00e4r: \" + sum);\n};\n\nK\u00f6rbar uppgift3 = () -> {\n    int sum = Arrays.stream(a3).sum();\n    System.out.println(\"3. Summan \u00e4r: \" + sum);\n};\n\nny tr\u00e5d(uppgift1).start();\nny tr\u00e5d(uppgift2).start();\nny tr\u00e5d(uppgift3).start();<\/code><\/pre>\n\n\n\n
Som du kan se fr\u00e5n koden ovan Kan k\u00f6ras<\/code> \u00e4r ett funktionellt gr\u00e4nssnitt. Det inneh\u00e5ller en enda abstrakt metod k\u00f6r()<\/code>
utan n\u00e5gra argument. Den Kan k\u00f6ras<\/code> gr\u00e4nssnitt b\u00f6r implementeras av alla klasser vars instanser \u00e4r avsedda att vara
som utf\u00f6rs av en tr\u00e5d.<\/p>\n\n\n\n
N\u00e4r du har definierat en uppgift kan du skapa en tr\u00e5d f\u00f6r att k\u00f6ra den. Detta kan g\u00f6ras via ny tr\u00e5d()<\/code> konstrukt\u00f6r som
tar Kan k\u00f6ras<\/code> som sitt argument.<\/p>\n\n\n\n
Det sista steget \u00e4r att start()<\/code> en nyuppr\u00e4ttad tr\u00e5d. I den API<\/a> det finns ocks\u00e5 k\u00f6r()<\/code> metoder i Kan k\u00f6ras<\/code> och i
Tr\u00e5d<\/code>. Detta \u00e4r dock inte ett s\u00e4tt att utnyttja samtidighet i Java. Ett direkt anrop till var och en av dessa metoder resulterar i
utf\u00f6ra uppgiften i samma tr\u00e5d som den main()<\/code> metoden k\u00f6rs.<\/p>\n\n\n\n
Tr\u00e5dpooler och exekutorer<\/h3>\n\n\n\n
N\u00e4r det finns m\u00e5nga uppgifter \u00e4r det inte en bra id\u00e9 att skapa en separat tr\u00e5d f\u00f6r varje uppgift. Att skapa en Tr\u00e5d<\/code> \u00e4r en
tungviktsoperation och det \u00e4r mycket b\u00e4ttre att \u00e5teranv\u00e4nda befintliga tr\u00e5dar \u00e4n att skapa nya.<\/p>\n\n\n\n
N\u00e4r ett program skapar m\u00e5nga kortlivade tr\u00e5dar \u00e4r det b\u00e4ttre att anv\u00e4nda en tr\u00e5dpool. Tr\u00e5dpoolen inneh\u00e5ller ett antal
tr\u00e5dar som \u00e4r redo att k\u00f6ras men som f\u00f6r n\u00e4rvarande inte \u00e4r aktiva. Att ge en Kan k\u00f6ras<\/code> till poolen g\u00f6r att en av tr\u00e5darna anropar funktionen
k\u00f6r()<\/code> metod f\u00f6r given Kan k\u00f6ras<\/code>. Efter att ha slutf\u00f6rt en uppgift finns tr\u00e5den fortfarande kvar och \u00e4r i ett vilol\u00e4ge.<\/p>\n\n\n\n
Okej, du fattar - f\u00f6redra tr\u00e5dpooler ist\u00e4llet f\u00f6r manuell skapelse. Men hur kan du anv\u00e4nda dig av tr\u00e5dpooler? Den Utf\u00f6rare<\/code>
klassen har ett antal statiska fabriksmetoder f\u00f6r att konstruera tr\u00e5dpooler. Till exempel newCachedThredPool()<\/code> skapar
en pool d\u00e4r nya tr\u00e5dar skapas efter behov och inaktiva tr\u00e5dar sparas i 60 sekunder. I motsats till detta,
newFixedThreadPool()<\/code> inneh\u00e5ller en fast upps\u00e4ttning tr\u00e5dar, d\u00e4r inaktiva tr\u00e5dar f\u00f6rvaras p\u00e5 obest\u00e4md tid.<\/p>\n\n\n\n
L\u00e5t oss se hur det kan fungera i v\u00e5rt exempel. Nu beh\u00f6ver vi inte skapa tr\u00e5dar manuellt. Ist\u00e4llet m\u00e5ste vi skapa
Utf\u00f6rarService<\/code> som tillhandah\u00e5ller en pool av tr\u00e5dar. Sedan kan vi tilldela uppgifter till den. Det sista steget \u00e4r att st\u00e4nga tr\u00e5den
pool f\u00f6r att undvika minnesl\u00e4ckage. Resten av den tidigare koden f\u00f6rblir densamma.<\/p>\n\n\n\n
ExecutorService executor = Executors.newCachedThreadPool();\n\nexecutor.submit(uppgift1);\nexecutor.submit(uppgift2);\nexecutor.submit(uppgift3);\n\nexekut\u00f6r.shutdown();<\/code><\/pre>\n\n\n\n
Kallbara<\/h3>\n\n\n\n
Kan k\u00f6ras<\/code> verkar vara ett smidigt s\u00e4tt att skapa samtidiga uppgifter, men det har en stor brist. Den kan inte returnera n\u00e5gon
v\u00e4rde. Dessutom kan vi inte avg\u00f6ra om en uppgift \u00e4r slutf\u00f6rd eller inte. Vi vet inte heller om den har slutf\u00f6rts
normalt eller exceptionellt. L\u00f6sningen p\u00e5 dessa problem \u00e4r Kallbara<\/code>.<\/p>\n\n\n\n
Kallbara<\/code> liknar Kan k\u00f6ras<\/code> p\u00e5 s\u00e4tt och vis \u00e4ven asynkrona uppgifter. Den st\u00f6rsta skillnaden \u00e4r att den kan
returnera ett v\u00e4rde. Returv\u00e4rdet kan vara av valfri (icke-primitiv) typ som Kallbara<\/code> gr\u00e4nssnittet \u00e4r en parameteriserad typ.
Kallbara<\/code> \u00e4r ett funktionellt gr\u00e4nssnitt som har anrop()<\/code> metod som kan ge en Undantag<\/code>.<\/p>\n\n\n\n
L\u00e5t oss nu se hur vi kan utnyttja Kallbara<\/code> i v\u00e5rt matrisproblem.<\/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};\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. Summan \u00e4r: \" + future1.get());\nSystem.out.println(\"2. Summan \u00e4r: \" + future2.get());\nSystem.out.println(\"3. Summan \u00e4r: \" + future3.get());\n\nExecutor.shutdown();<\/code><\/pre>\n\n\n\n
Okej, vi kan se hur Kallbara<\/code> skapas och sedan skickas till Utf\u00f6rarService<\/code>. Men vad i hela friden \u00e4r Framtid<\/code>?
Framtid<\/code> fungerar som en brygga mellan tr\u00e5dar. Summan av varje array produceras i en separat tr\u00e5d och vi beh\u00f6ver ett s\u00e4tt att
f\u00e5 tillbaka dessa resultat till main()<\/code>.<\/p>\n\n\n\n
F\u00f6r att h\u00e4mta resultatet fr\u00e5n Framtid<\/code> vi beh\u00f6ver ringa get()<\/code> metod. H\u00e4r kan en av tv\u00e5 saker h\u00e4nda. F\u00f6rst kommer
resultatet av ber\u00e4kningen som utf\u00f6rs av Kallbara<\/code> \u00e4r tillg\u00e4nglig. D\u00e5 f\u00e5r vi det omedelbart. F\u00f6r det andra \u00e4r resultatet inte
redo \u00e4nnu. I det fallet get()<\/code> metoden blockeras tills resultatet \u00e4r tillg\u00e4ngligt.<\/p>\n\n\n\n
ComputableFuture<\/h3>\n\n\n\n
Problemet med Framtid<\/code> \u00e4r att den fungerar enligt \"push-paradigmet\". N\u00e4r man anv\u00e4nder Framtid<\/code> m\u00e5ste du vara som en chef som
fr\u00e5gar st\u00e4ndigt: \"\u00c4r din uppgift klar? \u00c4r den klar?\" tills den ger ett resultat. Att agera under konstant press \u00e4r
dyrt. Mycket b\u00e4ttre tillv\u00e4gag\u00e5ngss\u00e4tt skulle vara att best\u00e4lla Framtid<\/code> vad den ska g\u00f6ra n\u00e4r den \u00e4r klar med sin uppgift. Tyv\u00e4rr \u00e4r det s\u00e5,
Framtid<\/code> kan inte g\u00f6ra det men ComputableFuture<\/code> kan.<\/p>\n\n\n\n
ComputableFuture<\/code> arbetar enligt \"pull-paradigmet\". Vi kan tala om f\u00f6r den vad den ska g\u00f6ra med resultatet n\u00e4r den har slutf\u00f6rt sina uppgifter. Den
\u00e4r ett exempel p\u00e5 ett asynkront tillv\u00e4gag\u00e5ngss\u00e4tt.<\/p>\n\n\n\n
ComputableFuture<\/code> fungerar perfekt med Kan k\u00f6ras<\/code> men inte med Kallbara<\/code>. Ist\u00e4llet \u00e4r det m\u00f6jligt att ge en uppgift till
ComputableFuture<\/code> i form av Leverant\u00f6r<\/code>.<\/p>\n\n\n\n
L\u00e5t oss se hur ovanst\u00e5ende f\u00f6rh\u00e5ller sig till v\u00e5rt 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, 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\u00f6rsta som sl\u00e5r en \u00e4r hur mycket kortare den h\u00e4r l\u00f6sningen \u00e4r. Dessutom ser det snyggt och prydligt ut.<\/p>\n\n\n\n
Uppgift till Kompletterbar framtid<\/code> kan tillhandah\u00e5llas av supplyAsync()<\/code> metod som tar Leverant\u00f6r<\/code> eller av runAsync()<\/code> att
tar Kan k\u00f6ras<\/code>. En callback - en del av koden som ska k\u00f6ras n\u00e4r en uppgift \u00e4r slutf\u00f6rd - definieras av thenAccept()<\/code>
metod.<\/p>\n\n\n\n
Slutsatser<\/h2>\n\n\n\n
Java<\/strong> erbjuder m\u00e5nga olika s\u00e4tt att hantera samtidighet. I den h\u00e4r artikeln har vi knappt ber\u00f6rt \u00e4mnet.<\/p>\n\n\n\n
Men vi har \u00e4nd\u00e5 g\u00e5tt igenom grunderna i Tr\u00e5d<\/code>, Kan k\u00f6ras<\/code>, Kallbara<\/code>, och KallbarFutur<\/code> vilket \u00e4r en bra po\u00e4ng
f\u00f6r vidare unders\u00f6kning av \u00e4mnet.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
L\u00e4s den f\u00f6rsta delen av v\u00e5r bloggserie om samtidighet i Java. I f\u00f6ljande artikel kommer vi att titta n\u00e4rmare p\u00e5 skillnader mellan tr\u00e5dar och processer, tr\u00e5dpooler, exekutorer och mycket 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\/sv\/blogg\/samtidighet-i-java-del-1-introduktion\/\" \/>\n<meta property=\"og:locale\" content=\"sv_SE\" \/>\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\/sv\/blogg\/samtidighet-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 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\":\"sv-SE\",\"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\":\"sv-SE\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"sv-SE\",\"@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\":\"sv-SE\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"sv-SE\",\"@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\":\"sv-SE\",\"@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\\\/sv\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Samtidighet i Java Del 1 - Introduktion - The Codest","description":"L\u00e4s den f\u00f6rsta delen av v\u00e5r bloggserie 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\/sv\/blogg\/samtidighet-i-java-del-1-introduktion\/","og_locale":"sv_SE","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\/sv\/blogg\/samtidighet-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 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":"sv-SE","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 - 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\u00e4s den f\u00f6rsta delen av v\u00e5r bloggserie om samtidighet i Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"sv-SE","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"sv-SE","@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":"sv-SE"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"sv-SE","@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":"sv-SE","@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\/sv\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/sv\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}