{"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":"gelijktijdigheid-in-java-deel-1-inleiding","status":"publish","type":"post","link":"https:\/\/thecodest.co\/nl\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"Concurrency in Java Deel 1 - Inleiding"},"content":{"rendered":"

In het algemeen is de conventionele programmeeraanpak sequentieel. Alles in een programma gebeurt stap voor stap.
Maar in feite draait de hele wereld parallel - het is de mogelijkheid om meer dan \u00e9\u00e9n taak tegelijkertijd uit te voeren.<\/p>\n\n\n\n

Draad vs. proces<\/h2>\n\n\n\n

Om geavanceerde onderwerpen te bespreken zoals gelijktijdigheid in Java<\/a><\/strong> of multithreading, moeten we het eens worden over enkele gemeenschappelijke definities om er zeker van te zijn dat we op dezelfde pagina zitten.<\/p>\n\n\n\n

Laten we beginnen met de basis. In de niet-sequenti\u00eble wereld hebben we twee soorten concurrency representanten: processen en
threads. Een proces is een instantie van het programma dat draait. Normaal gesproken is het ge\u00efsoleerd van andere processen.
Het besturingssysteem is verantwoordelijk voor het toewijzen van bronnen aan elk proces. Bovendien fungeert het als een geleider die
plant en controleert ze.<\/p>\n\n\n\n

Thread is een soort proces, maar op een lager niveau, daarom wordt het ook wel light thread genoemd. Meerdere threads kunnen in \u00e9\u00e9n
proces. Hier fungeert het programma als een scheduler en een controller voor threads. Op deze manier lijkt het alsof individuele programma's
meerdere taken tegelijkertijd.<\/p>\n\n\n\n

Het fundamentele verschil tussen threads en processen is het isolatieniveau. Het proces heeft zijn eigen set van
bronnen, terwijl de thread gegevens<\/a> met andere threads. Het lijkt misschien een foutgevoelige aanpak en dat is het ook. Voor
Laten we ons daar nu niet op richten, want dat valt buiten het bestek van dit artikel.<\/p>\n\n\n\n

Processen, threads - ok... Maar wat is concurrency precies? Concurrency betekent dat je meerdere taken tegelijk kunt uitvoeren.
tijd. Het betekent niet dat die taken gelijktijdig moeten worden uitgevoerd - dat is wat parallellisme is. Concurrenc in Javay<\/strong> ook niet
meerdere CPU's of zelfs meerdere cores nodig. Het kan worden bereikt in een single-core omgeving door gebruik te maken van
contextschakelen.<\/p>\n\n\n\n

Een term die gerelateerd is aan concurrency is multithreading. Dit is een eigenschap van programma's waarmee ze meerdere taken tegelijk kunnen uitvoeren. Niet elk programma gebruikt deze aanpak, maar de programma's die dat wel doen, kunnen multithreaded worden genoemd.<\/p>\n\n\n\n

We zijn bijna klaar, nog \u00e9\u00e9n definitie. Asynchronie betekent dat een programma niet-blokkerende bewerkingen uitvoert.
Het start een taak en gaat dan verder met andere dingen terwijl het wacht op het antwoord. Als het antwoord komt, kan het reageren<\/a> aan.<\/p>\n\n\n\n

Al die jazz<\/h2>\n\n\n\n

Standaard wordt elke Java-toepassing<\/strong> draait in \u00e9\u00e9n proces. In dat proces is er \u00e9\u00e9n thread gerelateerd aan de hoofd()<\/code> methode van
een applicatie. Zoals gezegd is het echter mogelijk om gebruik te maken van de mechanismen van meerdere threads binnen \u00e9\u00e9n
programma.<\/p>\n\n\n\n

Runnable<\/h3>\n\n\n\n

Draad<\/code> is een Java<\/strong> klasse waarin de magie gebeurt. Dit is de objectrepresentatie van de eerder genoemde thread. Naar
je eigen thread maken, kun je de Draad<\/code> klasse. Het is echter geen aanbevolen aanpak. Draden<\/code> moet worden gebruikt als een mechanisme om de taak uit te voeren. Taken zijn stukjes code<\/a> die we in een gelijktijdige modus willen uitvoeren. We kunnen ze defini\u00ebren met de Runnable<\/code> interface.<\/p>\n\n\n\n

Maar genoeg theorie, laten we de daad bij het woord voegen.<\/p>\n\n\n\n

Probleem<\/h3>\n\n\n\n

Stel dat we een aantal matrices met getallen hebben. Voor elke matrix willen we de som van de getallen in een matrix weten. Laten we
doen alsof er veel van zulke arrays zijn en elk ervan relatief groot is. In dergelijke omstandigheden willen we gebruik maken van concurrency en elke array als een aparte taak optellen.<\/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};\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. De som is: \" + som);\n};\n\nRunnable task2 = () -> {\n    int sum = Arrays.stream(a2).sum();\n    System.out.println(\"2. De som is: \" + som);\n};\n\nRunnable task3 = () -> {\n    int sum = Arrays.stream(a3).sum();\n    System.out.println(\"3. De som is: \" + som);\n};\n\nnew Thread(task1).start();\nnieuwe Thread(task2).start();\nnieuwe Thread(task3).start();<\/code><\/pre>\n\n\n\n
Zoals je kunt zien in de bovenstaande code Runnable<\/code> is een functionele interface. Het bevat \u00e9\u00e9n abstracte methode uitvoeren()<\/code>
zonder argumenten. De Runnable<\/code> interface moet ge\u00efmplementeerd worden door elke klasse waarvan de instanties bedoeld zijn om
uitgevoerd door een thread.<\/p>\n\n\n\n
Zodra je een taak hebt gedefinieerd, kun je een thread maken om de taak uit te voeren. Dit kan via nieuwe draad()<\/code> constructor die
neemt Runnable<\/code> als argument.<\/p>\n\n\n\n
De laatste stap is start()<\/code> een nieuw aangemaakte draad. In de API<\/a> er zijn ook uitvoeren()<\/code> methoden in Runnable<\/code> en in
Draad<\/code>. Dat is echter geen manier om gebruik te maken van concurrency in Java. Een directe aanroep naar elk van deze methoden resulteert in
de taak uitvoeren in dezelfde thread als de hoofd()<\/code> methode wordt uitgevoerd.<\/p>\n\n\n\n
Draadpools en uitvoerders<\/h3>\n\n\n\n
Als er veel taken zijn, is het geen goed idee om voor elke taak een aparte thread aan te maken. Een Draad<\/code> is een
en het is veel beter om bestaande threads te hergebruiken dan om nieuwe te maken.<\/p>\n\n\n\n
Als een programma veel kortstondige threads aanmaakt, is het beter om een threadpool te gebruiken. De threadpool bevat een aantal
threads die klaar zijn om te worden uitgevoerd, maar momenteel niet actief zijn. Een Runnable<\/code> naar de pool zorgt ervoor dat een van de threads de
uitvoeren()<\/code> methode van gegeven Runnable<\/code>. Na het voltooien van een taak bestaat de thread nog steeds en bevindt zich in een inactieve toestand.<\/p>\n\n\n\n
Ok, je snapt het - liever een threadpool dan handmatig aanmaken. Maar hoe kun je threadpools gebruiken? De Executeurs<\/code>
klasse heeft een aantal statische fabrieksmethoden voor het bouwen van threadpools. Bijvoorbeeld nieuweCachedThredPool()<\/code> cre\u00ebert
een pool waarin nieuwe threads worden aangemaakt als dat nodig is en niet-actieve threads 60 seconden worden vastgehouden. In tegenstelling,
newFixedThreadPool()<\/code> bevat een vaste set threads, waarin idle threads voor onbepaalde tijd worden bewaard.<\/p>\n\n\n\n
Laten we eens kijken hoe het in ons voorbeeld zou kunnen werken. Nu hoeven we threads niet handmatig aan te maken. In plaats daarvan moeten we
UitvoerderService<\/code> die zorgt voor een pool van threads. Vervolgens kunnen we er taken aan toewijzen. De laatste stap is het sluiten van de thread
pool om geheugenlekken te voorkomen. De rest van de vorige code blijft hetzelfde.<\/p>\n\n\n\n
ExecutorService executor = Executors.newCachedThreadPool();\n\nexecutor.submit(task1);\nexecutor.submit(task2);\nexecutor.submit(task3);\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Opvraagbaar<\/h3>\n\n\n\n
Runnable<\/code> lijkt een handige manier om gelijktijdige taken te maken, maar het heeft \u00e9\u00e9n grote tekortkoming. Het kan geen
waarde. Bovendien kunnen we niet bepalen of een taak voltooid is of niet. We weten ook niet of de taak is voltooid
normaal of uitzonderlijk. De oplossing voor deze kwalen is Opvraagbaar<\/code>.<\/p>\n\n\n\n
Opvraagbaar<\/code> is vergelijkbaar met Runnable<\/code> op een bepaalde manier ook asynchrone taken. Het belangrijkste verschil is dat het in staat is om
een waarde teruggeven. De retourwaarde kan van elk (niet-primitief) type zijn als de Opvraagbaar<\/code> interface is een geparametriseerd type.
Opvraagbaar<\/code> is een functionele interface die oproep()<\/code> methode die een Uitzondering<\/code>.<\/p>\n\n\n\n
Laten we nu eens kijken hoe we gebruik kunnen maken van Opvraagbaar<\/code> in ons matrixprobleem.<\/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};\nint[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};\n\nCallable task1 = () -> Arrays.stream(a1).sum();\nCallable task2 = () -> Arrays.stream(a2).som();\nCallable task3 = () -> Arrays.stream(a3).som();\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. De som is: \" + future1.get());\nSystem.out.println(\"2. De som is: \" + future2.get());\nSystem.out.println(\"3. De som is: \" + future3.get());\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Ok\u00e9, we kunnen zien hoe Opvraagbaar<\/code> wordt gemaakt en vervolgens ingediend bij UitvoerderService<\/code>. Maar wat is Toekomst<\/code>?
Toekomst<\/code> fungeert als een brug tussen threads. De som van elke array wordt geproduceerd in een aparte thread en we hebben een manier nodig om
die resultaten terugsturen naar hoofd()<\/code>.<\/p>\n\n\n\n
Om het resultaat op te halen uit Toekomst<\/code> moeten we bellen krijgen()<\/code> methode. Hier kunnen twee dingen gebeuren. Ten eerste wordt de
resultaat van de berekening uitgevoerd door Opvraagbaar<\/code> beschikbaar is. Dan krijgen we het onmiddellijk. Ten tweede is het resultaat niet
nog niet klaar. In dat geval krijgen()<\/code> methode zal blokkeren totdat het resultaat beschikbaar is.<\/p>\n\n\n\n
ComputableFuture<\/h3>\n\n\n\n
Het probleem met Toekomst<\/code> is dat het werkt in het 'push-paradigma'. Bij gebruik van Toekomst<\/code> je moet zijn als een baas die
vraagt voortdurend: \"Is je taak klaar? Is het klaar?\" totdat het resultaat oplevert. Handelen onder constante druk is
duur. Een veel betere aanpak zou zijn om Toekomst<\/code> wat te doen als het klaar is met zijn taak. Helaas,
Toekomst<\/code> kan dat niet doen, maar ComputableFuture<\/code> kan.<\/p>\n\n\n\n
ComputableFuture<\/code> werkt in het 'pull-paradigma'. We kunnen het vertellen wat te doen met het resultaat wanneer het zijn taken heeft voltooid. Het
is een voorbeeld van een asynchrone aanpak.<\/p>\n\n\n\n
ComputableFuture<\/code> werkt perfect met Runnable<\/code> maar niet met Opvraagbaar<\/code>. In plaats daarvan is het mogelijk om een taak te leveren aan
ComputableFuture<\/code> in de vorm van Leverancier<\/code>.<\/p>\n\n\n\n
Laten we eens kijken hoe het bovenstaande verband houdt met ons probleem.<\/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};\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
Het eerste wat opvalt is hoeveel korter deze oplossing is. Daarnaast ziet het er ook nog eens netjes en opgeruimd uit.<\/p>\n\n\n\n
Taak naar InvulbaarToekomst<\/code> kan worden geleverd door supplyAsync()<\/code> methode die Leverancier<\/code> of door runAsync()<\/code> dat
neemt Runnable<\/code>. Een callback - een stukje code dat moet worden uitgevoerd na het voltooien van een taak - wordt gedefinieerd door thenAccept()<\/code>
methode.<\/p>\n\n\n\n
Conclusies<\/h2>\n\n\n\n
Java<\/strong> biedt veel verschillende benaderingen van gelijktijdigheid. In dit artikel hebben we het onderwerp nauwelijks aangestipt.<\/p>\n\n\n\n
Niettemin hebben we de basisbeginselen van Draad<\/code>, Runnable<\/code>, Opvraagbaar<\/code>en CallableFuture<\/code> wat een goed punt is
voor verder onderzoek.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
Lees het eerste deel van onze blogserie over concurrency in Java. In het volgende artikel gaan we dieper in op de verschillen tussen threads en processen, thread pools, executors en nog veel meer!<\/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\/nl\/blog\/gelijktijdigheid-in-java-deel-1-inleiding\/\" \/>\n<meta property=\"og:locale\" content=\"nl_NL\" \/>\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\/nl\/blog\/gelijktijdigheid-in-java-deel-1-inleiding\/\" \/>\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\":\"nl-NL\",\"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\":\"nl-NL\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"nl-NL\",\"@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\":\"nl-NL\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"nl-NL\",\"@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\":\"nl-NL\",\"@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\\\/nl\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Concurrency in Java Deel 1 - Inleiding - The Codest","description":"Lees het eerste deel van onze blogserie over concurrency in 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\/nl\/blog\/gelijktijdigheid-in-java-deel-1-inleiding\/","og_locale":"nl_NL","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\/nl\/blog\/gelijktijdigheid-in-java-deel-1-inleiding\/","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":"nl-NL","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 Deel 1 - Inleiding - 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":"Lees het eerste deel van onze blogserie over concurrency in Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"nl-NL","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"nl-NL","@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":"nl-NL"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"The Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"nl-NL","@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":"nl-NL","@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\/nl\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/nl\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}