{"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":"concurrency-in-java-parte-1-introduzione","status":"publish","type":"post","link":"https:\/\/thecodest.co\/it\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"Concorrenza in Java Parte 1 - Introduzione"},"content":{"rendered":"

In generale, l'approccio convenzionale alla programmazione \u00e8 sequenziale. Tutto in un programma avviene un passo alla volta.
Ma, in realt\u00e0, il parallelo \u00e8 il modo in cui funziona il mondo intero: \u00e8 la capacit\u00e0 di eseguire pi\u00f9 di un compito contemporaneamente.<\/p>\n\n\n\n

Filo e processo<\/h2>\n\n\n\n

Per discutere di argomenti avanzati come concomitanza in Java<\/a><\/strong> o multithreading, dobbiamo trovare delle definizioni comuni per essere sicuri di essere sulla stessa lunghezza d'onda.<\/p>\n\n\n\n

Cominciamo con le basi. Nel mondo non sequenziale, abbiamo due tipi di rappresentazioni della concorrenza: processi e
thread. Un processo \u00e8 un'istanza del programma in esecuzione. Normalmente, \u00e8 isolato dagli altri processi.
Il sistema operativo \u00e8 responsabile dell'assegnazione delle risorse a ciascun processo. Inoltre, agisce come un conduttore che
programma e controlla.<\/p>\n\n\n\n

Il thread \u00e8 una sorta di processo ma a un livello inferiore, pertanto \u00e8 noto anche come thread leggero. Pi\u00f9 thread possono essere eseguiti in un
processo. In questo caso il programma agisce come scheduler e controllore dei thread. In questo modo i singoli programmi sembrano fare
pi\u00f9 compiti contemporaneamente.<\/p>\n\n\n\n

La differenza fondamentale tra thread e processi \u00e8 il livello di isolamento. Il processo ha un proprio insieme di
risorse, mentre il thread condivide dati<\/a> con altri thread. Pu\u00f2 sembrare un approccio a rischio di errori, e in effetti lo \u00e8. Per
Ora, non concentriamoci su questo aspetto perch\u00e9 esula dallo scopo di questo articolo.<\/p>\n\n\n\n

Processi, thread - ok... Ma cos'\u00e8 esattamente la concorrenza? Concorrenza significa che \u00e8 possibile eseguire pi\u00f9 attivit\u00e0 allo stesso tempo.
tempo. Non significa che questi compiti debbano essere eseguiti simultaneamente: questo \u00e8 il parallelismo. Concurrenc in Javay<\/strong> inoltre non
richiede la presenza di pi\u00f9 CPU o addirittura di pi\u00f9 core. \u00c8 possibile ottenerlo in un ambiente single-core sfruttando
commutazione di contesto.<\/p>\n\n\n\n

Un termine correlato alla concorrenza \u00e8 il multithreading. Si tratta di una caratteristica dei programmi che consente loro di eseguire pi\u00f9 compiti contemporaneamente. Non tutti i programmi utilizzano questo approccio, ma quelli che lo fanno possono essere definiti multithread.<\/p>\n\n\n\n

Siamo quasi pronti, manca solo una definizione. Asincronia significa che un programma esegue operazioni non bloccanti.
Avvia un compito e poi continua a svolgere altre attivit\u00e0 in attesa della risposta. Quando riceve la risposta, pu\u00f2 reagire<\/a> ad esso.<\/p>\n\n\n\n

Tutto questo jazz<\/h2>\n\n\n\n

Per impostazione predefinita, ogni Applicazione Java<\/strong> viene eseguito in un processo. In questo processo, c'\u00e8 un thread relativo al file main()<\/code> metodo di
un'applicazione. Tuttavia, come accennato, \u00e8 possibile sfruttare i meccanismi di pi\u00f9 thread all'interno di un'unica applicazione.
programma.<\/p>\n\n\n\n

Eseguibile<\/h3>\n\n\n\n

Il filo<\/code> \u00e8 un Java<\/strong> in cui avviene la magia. Questa \u00e8 la rappresentazione ad oggetti del thread di cui sopra. A
creare un proprio thread, \u00e8 possibile estendere il metodo Il filo<\/code> classe. Tuttavia, non \u00e8 un approccio consigliato. Fili<\/code> deve essere usato come meccanismo per eseguire il task. I task sono pezzi di codice<\/a> che vogliamo eseguire in modalit\u00e0 concorrente. Possiamo definirli utilizzando l'opzione Eseguibile<\/code> interfaccia.<\/p>\n\n\n\n

Ma basta con la teoria, mettiamo il nostro codice al posto della bocca.<\/p>\n\n\n\n

Problema<\/h3>\n\n\n\n

Supponiamo di avere una coppia di matrici di numeri. Per ogni matrice, vogliamo conoscere la somma dei numeri in una matrice. Facciamo
Si supponga che ci siano molti array di questo tipo e che ognuno di essi sia relativamente grande. In queste condizioni, vogliamo sfruttare la concorrenza e sommare ogni array come compito separato.<\/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 somma \u00e8: \" + sum);\n};\n\nRunnable task2 = () -> {\n    int sum = Arrays.stream(a2).sum();\n    System.out.println(\"2. La somma \u00e8: \" + sum);\n};\n\nRunnable task3 = () -> {\n    int sum = Arrays.stream(a3).sum();\n    System.out.println(\"3. La somma \u00e8: \" + sum);\n};\n\nnuovo Thread(task1).start();\nnuovo Thread(task2).start();\nnuovo Thread(task3).start();<\/code><\/pre>\n\n\n\n
Come si pu\u00f2 vedere dal codice qui sopra Eseguibile<\/code> \u00e8 un'interfaccia funzionale. Contiene un singolo metodo astratto eseguire()<\/code>
senza argomenti. Il Eseguibile<\/code> dovrebbe essere implementata da qualsiasi classe le cui istanze siano destinate ad essere
eseguito da un thread.<\/p>\n\n\n\n
Una volta definito un task, \u00e8 possibile creare un thread per eseguirlo. Questo pu\u00f2 essere fatto tramite nuovo thread()<\/code> costruttore che
prende Eseguibile<\/code> come argomento.<\/p>\n\n\n\n
Il passo finale consiste nel start()<\/code> una discussione appena creata. Nel API<\/a> ci sono anche eseguire()<\/code> metodi in Eseguibile<\/code> e in
Il filo<\/code>. Tuttavia, questo non \u00e8 un modo per sfruttare la concorrenza in Java. Una chiamata diretta a ciascuno di questi metodi risulta in
eseguire l'attivit\u00e0 nello stesso thread in cui si trova il main()<\/code> viene eseguito il metodo.<\/p>\n\n\n\n
Pool di thread ed esecutori<\/h3>\n\n\n\n
Quando ci sono molti task, creare un thread separato per ciascuno di essi non \u00e8 una buona idea. Creare un thread Il filo<\/code> \u00e8 un
\u00c8 un'operazione pesante ed \u00e8 molto meglio riutilizzare i thread esistenti piuttosto che crearne di nuovi.<\/p>\n\n\n\n
Quando un programma crea molti thread di breve durata, \u00e8 meglio utilizzare un pool di thread. Il pool di thread contiene un certo numero di
filoni pronti per essere eseguiti ma attualmente non attivi. Dare un Eseguibile<\/code> al pool fa s\u00ec che uno dei thread richiami il metodo
eseguire()<\/code> metodo di data Eseguibile<\/code>. Dopo aver completato un'attivit\u00e0, il thread esiste ancora e si trova in uno stato di inattivit\u00e0.<\/p>\n\n\n\n
Ok, avete capito: preferite i pool di thread alla creazione manuale. Ma come si possono utilizzare i pool di thread? Il Esecutori<\/code>
ha una serie di metodi statici di fabbrica per la costruzione di pool di thread. Ad esempio nuovoCachedThredPool()<\/code> crea
un pool in cui vengono creati nuovi thread in base alle necessit\u00e0 e i thread inattivi vengono mantenuti per 60 secondi. Al contrario,
newFixedThreadPool()<\/code> contiene un insieme fisso di thread, in cui i thread inattivi vengono mantenuti indefinitamente.<\/p>\n\n\n\n
Vediamo come potrebbe funzionare nel nostro esempio. Ora non \u00e8 necessario creare manualmente i thread. Dobbiamo invece creare
Servizio Esecutore<\/code> che fornisce un pool di thread. Poi si possono assegnare i compiti. L'ultimo passo \u00e8 chiudere il thread
per evitare perdite di memoria. Il resto del codice precedente rimane invariato.<\/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
Callable<\/h3>\n\n\n\n
Eseguibile<\/code> sembra un modo intelligente per creare task concorrenti, ma ha un grosso difetto. Non pu\u00f2 restituire alcun
valore. Inoltre, non possiamo stabilire se un'attivit\u00e0 \u00e8 terminata o meno. Non sappiamo nemmeno se \u00e8 stato completato.
normalmente o eccezionalmente. La soluzione a questi mali \u00e8 Callable<\/code>.<\/p>\n\n\n\n
Callable<\/code> \u00e8 simile a Eseguibile<\/code> in un certo senso avvolge anche i task asincroni. La differenza principale \u00e8 che \u00e8 in grado di
restituiscono un valore. Il valore di ritorno pu\u00f2 essere di qualsiasi tipo (non primitivo), come il parametro Callable<\/code> \u00e8 un tipo parametrizzato.
Callable<\/code> \u00e8 un'interfaccia funzionale che ha chiamare()<\/code> che pu\u00f2 lanciare un metodo Eccezione<\/code>.<\/p>\n\n\n\n
Vediamo ora come fare leva su Callable<\/code> nel nostro problema dell'array.<\/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 somma \u00e8: \" + future1.get());\nSystem.out.println(\"2. La somma \u00e8: \" + future2.get());\nSystem.out.println(\"3. La somma \u00e8: \" + future3.get());\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Ok, possiamo vedere come Callable<\/code> viene creato e poi inviato a Servizio Esecutore<\/code>. Ma cosa diavolo \u00e8 Futuro<\/code>?
Futuro<\/code> funge da ponte tra i thread. La somma di ogni array viene prodotta in un thread separato e abbiamo bisogno di un modo per
riportare i risultati a main()<\/code>.<\/p>\n\n\n\n
Per recuperare il risultato da Futuro<\/code> dobbiamo chiamare get()<\/code> metodo. In questo caso possono accadere due cose. In primo luogo, il metodo
risultato del calcolo eseguito da Callable<\/code> \u00e8 disponibile. Allora lo otteniamo immediatamente. In secondo luogo, il risultato non \u00e8
pronto. In questo caso get()<\/code> si bloccher\u00e0 finch\u00e9 il risultato non sar\u00e0 disponibile.<\/p>\n\n\n\n
Futuro Computabile<\/h3>\n\n\n\n
Il problema con Futuro<\/code> \u00e8 che funziona secondo il \"paradigma push\". Quando si utilizza Futuro<\/code> devi essere come un capo che
chiede costantemente: \"Il tuo compito \u00e8 finito? \u00c8 pronto?\" finch\u00e9 non fornisce un risultato. Agire sotto costante pressione \u00e8
costoso. Un approccio decisamente migliore sarebbe quello di ordinare Futuro<\/code> cosa fare quando \u00e8 pronto per il suo compito. Purtroppo,
Futuro<\/code> non pu\u00f2 farlo, ma Futuro Computabile<\/code> pu\u00f2.<\/p>\n\n\n\n
Futuro Computabile<\/code> funziona secondo il \"paradigma pull\". Possiamo dirgli cosa fare con il risultato quando ha completato i suoi compiti. Esso
\u00e8 un esempio di approccio asincrono.<\/p>\n\n\n\n
Futuro Computabile<\/code> funziona perfettamente con Eseguibile<\/code> ma non con Callable<\/code>. Invece, \u00e8 possibile fornire un compito a
Futuro Computabile<\/code> sotto forma di Fornitore<\/code>.<\/p>\n\n\n\n
Vediamo come quanto detto sopra si collega al nostro problema.<\/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 prima cosa che colpisce \u00e8 quanto sia pi\u00f9 corta questa soluzione. Inoltre, ha un aspetto pulito e ordinato.<\/p>\n\n\n\n
Compito di CompletabileFuturo<\/code> pu\u00f2 essere fornito da supplyAsync()<\/code> che prende il metodo Fornitore<\/code> o da runAsync()<\/code> che
prende Eseguibile<\/code>. Un callback - un pezzo di codice che deve essere eseguito al completamento dell'attivit\u00e0 - \u00e8 definito da thenAccept()<\/code>
metodo.<\/p>\n\n\n\n
Conclusioni<\/h2>\n\n\n\n
Java<\/strong> offre molti approcci diversi alla concorrenza. In questo articolo abbiamo appena accennato all'argomento.<\/p>\n\n\n\n
Tuttavia, abbiamo trattato le basi di Il filo<\/code>, Eseguibile<\/code>, Callable<\/code>, e CallableFuture<\/code> che pone una buona questione
per approfondire l'argomento.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
Leggete la prima parte della nostra serie di blog dedicata alla concorrenza in Java. Nel prossimo articolo daremo uno sguardo pi\u00f9 approfondito alle differenze tra thread e processi, ai pool di thread, agli esecutori e a molto altro ancora!<\/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\/it\/blog\/concurrency-in-java-parte-1-introduzione\/\" \/>\n<meta property=\"og:locale\" content=\"it_IT\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Concurrency in Java Part 1 - Introduction - The Codest\" \/>\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\/it\/blog\/concurrency-in-java-parte-1-introduzione\/\" \/>\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,\"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\":\"it-IT\",\"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\",\"author\":{\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/person\\\/7e3fe41dfa4f4e41a7baad4c6e0d4f76\"},\"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\":\"it-IT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@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\":\"\",\"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\":\"it-IT\"},{\"@type\":\"Person\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#\\\/schema\\\/person\\\/7e3fe41dfa4f4e41a7baad4c6e0d4f76\",\"name\":\"thecodest\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"it-IT\",\"@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\\\/it\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Concorrenza in Java Parte 1 - Introduzione - The Codest","description":"Leggete la prima parte della nostra serie di blog dedicata alla concorrenza 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\/it\/blog\/concurrency-in-java-parte-1-introduzione\/","og_locale":"it_IT","og_type":"article","og_title":"Concurrency in Java Part 1 - Introduction - The Codest","og_description":"Read the first part of our blog series devoted to concurrency in Java.","og_url":"https:\/\/thecodest.co\/it\/blog\/concurrency-in-java-parte-1-introduzione\/","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,"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":"it-IT","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":"Concorrenza in Java Parte 1 - Introduzione - 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","author":{"@id":"https:\/\/thecodest.co\/#\/schema\/person\/7e3fe41dfa4f4e41a7baad4c6e0d4f76"},"description":"Leggete la prima parte della nostra serie di blog dedicata alla concorrenza in Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"it-IT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"it-IT","@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":"","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":"it-IT"},{"@type":"Person","@id":"https:\/\/thecodest.co\/#\/schema\/person\/7e3fe41dfa4f4e41a7baad4c6e0d4f76","name":"thecodest","image":{"@type":"ImageObject","inLanguage":"it-IT","@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\/it\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/it\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}