{"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":"la-concurrence-en-java-partie-1-introduction","status":"publish","type":"post","link":"https:\/\/thecodest.co\/fr\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"Concurrence en Java Partie 1 - Introduction"},"content":{"rendered":"

En g\u00e9n\u00e9ral, l'approche conventionnelle de la programmation est s\u00e9quentielle. Dans un programme, tout se passe \u00e9tape par \u00e9tape.
Mais, en fait, le parall\u00e8le est le mode de fonctionnement du monde entier - c'est la capacit\u00e9 d'ex\u00e9cuter plus d'une t\u00e2che simultan\u00e9ment.<\/p>\n\n\n\n

Fil ou processus<\/h2>\n\n\n\n

Pour discuter de sujets avanc\u00e9s tels que la concurrence dans Java<\/a><\/strong> ou le multithreading, nous devons nous mettre d'accord sur des d\u00e9finitions communes pour \u00eatre s\u00fbrs d'\u00eatre sur la m\u00eame longueur d'onde.<\/p>\n\n\n\n

Commen\u00e7ons par les bases. Dans le monde non s\u00e9quentiel, nous disposons de deux types de repr\u00e9sentants de la concurrence : les processus et les
threads. Un processus est une instance du programme en cours d'ex\u00e9cution. Normalement, il est isol\u00e9 des autres processus.
Le syst\u00e8me d'exploitation est responsable de l'attribution des ressources \u00e0 chaque processus. En outre, il agit comme un chef d'orchestre qui
les planifie et les contr\u00f4le.<\/p>\n\n\n\n

Le thread est une sorte de processus mais \u00e0 un niveau inf\u00e9rieur, c'est pourquoi il est \u00e9galement connu sous le nom de thread l\u00e9ger. Plusieurs threads peuvent s'ex\u00e9cuter dans un
processus. Dans ce cas, le programme agit comme un planificateur et un contr\u00f4leur pour les threads. De cette mani\u00e8re, les programmes individuels semblent faire
plusieurs t\u00e2ches en m\u00eame temps.<\/p>\n\n\n\n

La diff\u00e9rence fondamentale entre les threads et les processus est le niveau d'isolation. Le processus dispose de son propre ensemble de
ressources, tandis que le fil partage donn\u00e9es<\/a> avec d'autres fils. Cette approche peut sembler sujette \u00e0 des erreurs, et c'est effectivement le cas. Pour les
mais ne nous attardons pas sur ce point, qui d\u00e9passe le cadre de cet article.<\/p>\n\n\n\n

Processus, threads - d'accord... Mais qu'est-ce que la simultan\u00e9it\u00e9 ? La simultan\u00e9it\u00e9 signifie que vous pouvez ex\u00e9cuter plusieurs t\u00e2ches en m\u00eame temps.
temps. Cela ne signifie pas que ces t\u00e2ches doivent \u00eatre ex\u00e9cut\u00e9es simultan\u00e9ment - c'est ce qu'on appelle le parall\u00e9lisme. Concurrenc dans Javay<\/strong> n'est pas non plus
ne n\u00e9cessite pas de disposer de plusieurs unit\u00e9s centrales ou m\u00eame de plusieurs c\u0153urs. Il est possible d'y parvenir dans un environnement \u00e0 un seul c\u0153ur en tirant parti de la technologie
le changement de contexte.<\/p>\n\n\n\n

Le multithreading est un terme li\u00e9 \u00e0 la concurrence. Il s'agit d'une caract\u00e9ristique des programmes qui leur permet d'ex\u00e9cuter plusieurs t\u00e2ches \u00e0 la fois. Tous les programmes n'utilisent pas cette approche, mais ceux qui le font peuvent \u00eatre qualifi\u00e9s de multithreads.<\/p>\n\n\n\n

Nous sommes presque pr\u00eats \u00e0 partir, il ne reste plus qu'une d\u00e9finition. L'asynchronisme signifie qu'un programme effectue des op\u00e9rations non bloquantes.
Il initie une t\u00e2che et passe ensuite \u00e0 autre chose en attendant la r\u00e9ponse. Lorsqu'il re\u00e7oit la r\u00e9ponse, il peut r\u00e9agir<\/a> \u00e0 elle.<\/p>\n\n\n\n

Tout ce jazz<\/h2>\n\n\n\n

Par d\u00e9faut, chaque Application Java<\/strong> s'ex\u00e9cute dans un seul processus. Dans ce processus, il y a un fil d'ex\u00e9cution li\u00e9 \u00e0 l'application main()<\/code> m\u00e9thode de
une application. Cependant, comme nous l'avons mentionn\u00e9, il est possible d'exploiter les m\u00e9canismes de threads multiples au sein d'une m\u00eame application.
programme.<\/p>\n\n\n\n

Ex\u00e9cutables<\/h3>\n\n\n\n

Fil<\/code> est un Java<\/strong> dans laquelle la magie op\u00e8re. Il s'agit de la repr\u00e9sentation de l'objet du fil de discussion mentionn\u00e9 ci-dessus. Pour
cr\u00e9er votre propre thread, vous pouvez \u00e9tendre la fonction Fil<\/code> classe. Toutefois, cette approche n'est pas recommand\u00e9e. Fils<\/code> doit \u00eatre utilis\u00e9 comme m\u00e9canisme d'ex\u00e9cution de la t\u00e2che. Les t\u00e2ches sont des \u00e9l\u00e9ments de code<\/a> que nous voulons ex\u00e9cuter en mode concurrent. Nous pouvons les d\u00e9finir \u00e0 l'aide de la fonction Ex\u00e9cutables<\/code> l'interface.<\/p>\n\n\n\n

Mais tr\u00eave de th\u00e9orie, joignons le geste \u00e0 la parole.<\/p>\n\n\n\n

Probl\u00e8me<\/h3>\n\n\n\n

Supposons que nous ayons deux tableaux de nombres. Pour chaque tableau, nous voulons conna\u00eetre la somme des nombres qu'il contient. Soit
Supposons qu'il existe un grand nombre de tableaux de ce type et que chacun d'entre eux est relativement volumineux. Dans ces conditions, nous voulons utiliser la concurrence et additionner chaque tableau comme une t\u00e2che distincte.<\/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\nRunnable task1 = () -> {\n    int sum = Arrays.stream(a1).sum() ;\n    System.out.println(\"1. La somme est : \" + sum) ;\n} ;\n\nEx\u00e9cutable task2 = () -> {\n    int sum = Arrays.stream(a2).sum() ;\n    System.out.println(\"2. La somme est : \" + sum) ;\n} ;\n\nEx\u00e9cutable task3 = () -> {\n    int sum = Arrays.stream(a3).sum() ;\n    System.out.println(\"3. La somme est : \" + sum) ;\n} ;\n\nnew Thread(task1).start() ;\nnew Thread(task2).start() ;\nnew Thread(task3).start() ;<\/code><\/pre>\n\n\n\n
Comme vous pouvez le voir dans le code ci-dessus Ex\u00e9cutables<\/code> est une interface fonctionnelle. Elle contient une seule m\u00e9thode abstraite ex\u00e9cuter()<\/code>
sans arguments. Les Ex\u00e9cutables<\/code> doit \u00eatre mise en \u0153uvre par toute classe dont les instances sont cens\u00e9es \u00eatre des
ex\u00e9cut\u00e9 par un thread.<\/p>\n\n\n\n
Une fois que vous avez d\u00e9fini une t\u00e2che, vous pouvez cr\u00e9er un thread pour l'ex\u00e9cuter. Pour ce faire, il suffit d'utiliser la commande nouveau Thread()<\/code> qui
prend Ex\u00e9cutables<\/code> comme argument.<\/p>\n\n\n\n
La derni\u00e8re \u00e9tape consiste \u00e0 d\u00e9marrer()<\/code> un fil de discussion nouvellement cr\u00e9\u00e9. Dans le API<\/a> il y a aussi ex\u00e9cuter()<\/code> m\u00e9thodes en Ex\u00e9cutables<\/code> et en
Fil<\/code>. Cependant, ce n'est pas une fa\u00e7on de tirer parti de la concurrence en Java. Un appel direct \u00e0 chacune de ces m\u00e9thodes se traduit par
l'ex\u00e9cution de la t\u00e2che dans le m\u00eame thread que le main()<\/code> s'ex\u00e9cute.<\/p>\n\n\n\n
Pools de threads et ex\u00e9cuteurs<\/h3>\n\n\n\n
Lorsqu'il y a beaucoup de t\u00e2ches, il n'est pas judicieux de cr\u00e9er un fil de discussion distinct pour chacune d'entre elles. La cr\u00e9ation d'un Fil<\/code> est un
Il est donc pr\u00e9f\u00e9rable de r\u00e9utiliser les threads existants plut\u00f4t que d'en cr\u00e9er de nouveaux.<\/p>\n\n\n\n
Lorsqu'un programme cr\u00e9e de nombreux threads de courte dur\u00e9e, il est pr\u00e9f\u00e9rable d'utiliser un pool de threads. Le pool de threads contient un certain nombre de
les fils de discussion pr\u00eats \u00e0 \u00eatre ex\u00e9cut\u00e9s mais qui ne sont pas encore actifs. L'attribution d'un Ex\u00e9cutables<\/code> au pool, l'un des threads appelle la fonction
ex\u00e9cuter()<\/code> d'une m\u00e9thode donn\u00e9e Ex\u00e9cutables<\/code>. Apr\u00e8s avoir termin\u00e9 une t\u00e2che, le thread existe toujours et se trouve dans un \u00e9tat d'inactivit\u00e9.<\/p>\n\n\n\n
Ok, vous l'avez compris - pr\u00e9f\u00e9rez le pool de threads \u00e0 la cr\u00e9ation manuelle. Mais comment utiliser les pools de threads ? Les Ex\u00e9cuteurs<\/code>
poss\u00e8de un certain nombre de m\u00e9thodes d'usine statiques pour construire des pools de threads. Par exemple, la m\u00e9thode newCachedThredPool()<\/code> cr\u00e9e
un pool dans lequel de nouveaux threads sont cr\u00e9\u00e9s en fonction des besoins et o\u00f9 les threads inactifs sont conserv\u00e9s pendant 60 secondes. En revanche,
newFixedThreadPool()<\/code> contient un ensemble fixe de threads, dans lequel les threads inactifs sont conserv\u00e9s ind\u00e9finiment.<\/p>\n\n\n\n
Voyons comment cela pourrait fonctionner dans notre exemple. D\u00e9sormais, nous n'avons plus besoin de cr\u00e9er des fils de discussion manuellement. Au lieu de cela, nous devons cr\u00e9er
ExecutorService<\/code> qui fournit un pool de threads. Nous pouvons ensuite lui assigner des t\u00e2ches. La derni\u00e8re \u00e9tape consiste \u00e0 fermer le thread
pour \u00e9viter les fuites de m\u00e9moire. Le reste du code pr\u00e9c\u00e9dent reste inchang\u00e9.<\/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
Appelable<\/h3>\n\n\n\n
Ex\u00e9cutables<\/code> semble \u00eatre un moyen astucieux de cr\u00e9er des t\u00e2ches concurrentes, mais il pr\u00e9sente un d\u00e9faut majeur. Elle ne peut pas renvoyer de
valeur. De plus, nous ne pouvons pas d\u00e9terminer si une t\u00e2che est termin\u00e9e ou non. Nous ne savons pas non plus si elle est termin\u00e9e
normalement ou exceptionnellement. La solution \u00e0 ces maux est Appelable<\/code>.<\/p>\n\n\n\n
Appelable<\/code> est similaire \u00e0 Ex\u00e9cutables<\/code> d'une certaine mani\u00e8re, il englobe \u00e9galement les t\u00e2ches asynchrones. La principale diff\u00e9rence est qu'il est capable de
renvoie une valeur. La valeur de retour peut \u00eatre de n'importe quel type (non primitif) comme l'indique l'attribut Appelable<\/code> est un type param\u00e9tr\u00e9.
Appelable<\/code> est une interface fonctionnelle qui a call()<\/code> qui peut d\u00e9clencher un Exception<\/code>.<\/p>\n\n\n\n
Voyons maintenant comment nous pouvons tirer parti de l'effet de levier Appelable<\/code> dans notre probl\u00e8me de tableau.<\/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. La somme est : \" + future1.get()) ;\nSystem.out.println(\"2. la somme est : \" + future2.get()) ;\nSystem.out.println(\"3. la somme est : \" + future3.get()) ;\n\nexecutor.shutdown() ;<\/code><\/pre>\n\n\n\n
D'accord, nous pouvons voir comment Appelable<\/code> est cr\u00e9\u00e9 et soumis \u00e0 l'autorit\u00e9 comp\u00e9tente de l ExecutorService<\/code>. Mais qu'est-ce que c'est que L'avenir<\/code>?
L'avenir<\/code> agit comme un pont entre les threads. La somme de chaque tableau est produite dans un thread s\u00e9par\u00e9 et nous avons besoin d'un moyen pour
de renvoyer ces r\u00e9sultats \u00e0 main()<\/code>.<\/p>\n\n\n\n
Pour r\u00e9cup\u00e9rer le r\u00e9sultat de L'avenir<\/code> nous devons appeler get()<\/code> m\u00e9thode. Ici, deux choses peuvent se produire. Premi\u00e8rement, la m\u00e9thode
le r\u00e9sultat du calcul effectu\u00e9 par Appelable<\/code> est disponible. Nous l'obtenons alors imm\u00e9diatement. Deuxi\u00e8mement, le r\u00e9sultat n'est pas
encore pr\u00eat. Dans ce cas, les get()<\/code> se bloquera jusqu'\u00e0 ce que le r\u00e9sultat soit disponible.<\/p>\n\n\n\n
ComputableFuture<\/h3>\n\n\n\n
Le probl\u00e8me avec L'avenir<\/code> est qu'il fonctionne selon le \"paradigme de la pouss\u00e9e\". Lorsque l'on utilise L'avenir<\/code> il faut \u00eatre comme un patron qui
demande constamment : \"Votre t\u00e2che est-elle accomplie ? Est-elle pr\u00eate ?\" jusqu'\u00e0 ce qu'elle fournisse un r\u00e9sultat. Agir sous une pression constante, c'est
co\u00fbteux. La meilleure solution serait de commander L'avenir<\/code> ce qu'il doit faire lorsqu'il est pr\u00eat \u00e0 accomplir sa t\u00e2che. Malheureusement,
L'avenir<\/code> ne peut pas le faire, mais ComputableFuture<\/code> peut.<\/p>\n\n\n\n
ComputableFuture<\/code> fonctionne selon le paradigme \"pull\". Nous pouvons lui dire ce qu'il doit faire du r\u00e9sultat lorsqu'il a accompli ses t\u00e2ches. Il
est un exemple d'approche asynchrone.<\/p>\n\n\n\n
ComputableFuture<\/code> fonctionne parfaitement avec Ex\u00e9cutables<\/code> mais pas avec Appelable<\/code>. Au lieu de cela, il est possible de fournir une t\u00e2che \u00e0
ComputableFuture<\/code> sous forme de Fournisseur<\/code>.<\/p>\n\n\n\n
Voyons comment ce qui pr\u00e9c\u00e8de s'applique \u00e0 notre probl\u00e8me.<\/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
La premi\u00e8re chose qui frappe, c'est que cette solution est beaucoup plus courte. En outre, elle a un aspect soign\u00e9 et ordonn\u00e9.<\/p>\n\n\n\n
T\u00e2che \u00e0 CompletableFuture<\/code> peut \u00eatre fournie par supplyAsync()<\/code> qui prend en compte la m\u00e9thode Fournisseur<\/code> ou par runAsync()<\/code> que
prend Ex\u00e9cutables<\/code>. Un rappel - un morceau de code qui doit \u00eatre ex\u00e9cut\u00e9 \u00e0 la fin d'une t\u00e2che - est d\u00e9fini par thenAccept()<\/code>
m\u00e9thode.<\/p>\n\n\n\n
Conclusions<\/h2>\n\n\n\n
Java<\/strong> propose un grand nombre d'approches diff\u00e9rentes de la concurrence. Dans cet article, nous n'avons fait qu'effleurer le sujet.<\/p>\n\n\n\n
N\u00e9anmoins, nous avons couvert les bases de Fil<\/code>, Ex\u00e9cutables<\/code>, Appelable<\/code>et CallableFuture<\/code> ce qui constitue un bon point
pour un examen plus approfondi du sujet.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
Lisez la premi\u00e8re partie de notre s\u00e9rie de blogs consacr\u00e9e \u00e0 la concurrence en Java. Dans l'article suivant, nous examinerons de plus pr\u00e8s les diff\u00e9rences entre les threads et les processus, les pools de threads, les ex\u00e9cuteurs et bien d'autres choses encore !<\/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\/fr\/blog\/la-concurrence-en-java-partie-1-introduction\/\" \/>\n<meta property=\"og:locale\" content=\"fr_FR\" \/>\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\/fr\/blog\/la-concurrence-en-java-partie-1-introduction\/\" \/>\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\":\"fr-FR\",\"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\":\"fr-FR\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@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\":\"fr-FR\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"fr-FR\",\"@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\":\"fr-FR\",\"@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\\\/fr\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Concurrence en Java Partie 1 - Introduction - The Codest","description":"Lisez la premi\u00e8re partie de notre s\u00e9rie de blogs consacr\u00e9e \u00e0 la concurrence en 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\/fr\/blog\/la-concurrence-en-java-partie-1-introduction\/","og_locale":"fr_FR","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\/fr\/blog\/la-concurrence-en-java-partie-1-introduction\/","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":"fr-FR","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":"Concurrence en Java Partie 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":"Lisez la premi\u00e8re partie de notre s\u00e9rie de blogs consacr\u00e9e \u00e0 la concurrence en Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"fr-FR","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"fr-FR","@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":"fr-FR"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"The Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"fr-FR","@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":"fr-FR","@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\/fr\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/fr\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}