{"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":"concorrencia-em-java-parte-1-introducao","status":"publish","type":"post","link":"https:\/\/thecodest.co\/pt\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"Concorr\u00eancia em Java Parte 1 - Introdu\u00e7\u00e3o"},"content":{"rendered":"

Em geral, a abordagem de programa\u00e7\u00e3o convencional \u00e9 sequencial. Tudo num programa acontece um passo de cada vez.
Mas, na verdade, o paralelo \u00e9 a forma como o mundo inteiro funciona - \u00e9 a capacidade de executar mais do que uma tarefa em simult\u00e2neo.<\/p>\n\n\n\n

Linha vs. processo<\/h2>\n\n\n\n

Para debater temas avan\u00e7ados como concorr\u00eancia em Java<\/a><\/strong> ou multithreading, temos de chegar a acordo sobre algumas defini\u00e7\u00f5es comuns para termos a certeza de que estamos na mesma p\u00e1gina.<\/p>\n\n\n\n

Comecemos pelo b\u00e1sico. No mundo n\u00e3o-sequencial, temos dois tipos de representa\u00e7\u00f5es de concorr\u00eancia: processos e
threads. Um processo \u00e9 uma inst\u00e2ncia do programa em execu\u00e7\u00e3o. Normalmente, est\u00e1 isolado de outros processos.
O sistema operativo \u00e9 respons\u00e1vel pela atribui\u00e7\u00e3o de recursos a cada processo. Al\u00e9m disso, actua como um condutor que
programa e controla-os.<\/p>\n\n\n\n

A thread \u00e9 uma esp\u00e9cie de processo, mas num n\u00edvel inferior, pelo que tamb\u00e9m \u00e9 conhecida como light thread. V\u00e1rias threads podem ser executadas numa
processo. Aqui o programa actua como um agendador e um controlador de threads. Desta forma, os programas individuais parecem fazer
v\u00e1rias tarefas ao mesmo tempo.<\/p>\n\n\n\n

A diferen\u00e7a fundamental entre threads e processos \u00e9 o n\u00edvel de isolamento. O processo tem seu pr\u00f3prio conjunto de
recursos, enquanto o thread partilha dados<\/a> com outras linhas. Pode parecer uma abordagem propensa a erros e, de facto, \u00e9. Para
N\u00e3o nos vamos debru\u00e7ar sobre isso, uma vez que ultrapassa o \u00e2mbito deste artigo.<\/p>\n\n\n\n

Processos, threads - ok... Mas o que \u00e9 exatamente a concorr\u00eancia? Concorr\u00eancia significa que \u00e9 poss\u00edvel executar v\u00e1rias tarefas ao mesmo tempo
tempo. N\u00e3o significa que essas tarefas tenham de ser executadas em simult\u00e2neo - \u00e9 isso que \u00e9 o paralelismo. Concurrenc em Javay<\/strong> tamb\u00e9m n\u00e3o
requer que tenha v\u00e1rias CPUs ou mesmo v\u00e1rios n\u00facleos. Pode ser conseguido num ambiente de n\u00facleo \u00fanico, tirando partido de
mudan\u00e7a de contexto.<\/p>\n\n\n\n

Um termo relacionado com a concorr\u00eancia \u00e9 o multithreading. Esta \u00e9 uma carater\u00edstica dos programas que lhes permite executar v\u00e1rias tarefas ao mesmo tempo. Nem todos os programas utilizam esta abordagem, mas os que o fazem podem ser designados por multithreaded.<\/p>\n\n\n\n

Estamos quase prontos para come\u00e7ar, s\u00f3 mais uma defini\u00e7\u00e3o. Assincronia significa que um programa executa opera\u00e7\u00f5es sem bloqueio.
Inicia uma tarefa e depois continua com outras coisas enquanto espera pela resposta. Quando obt\u00e9m a resposta, pode reagir<\/a> a ele.<\/p>\n\n\n\n

Todo esse jazz<\/h2>\n\n\n\n

Por defeito, cada Aplica\u00e7\u00e3o Java<\/strong> \u00e9 executado num processo. Nesse processo, existe um thread relacionado com o principal()<\/code> m\u00e9todo de
uma aplica\u00e7\u00e3o. No entanto, como j\u00e1 foi referido, \u00e9 poss\u00edvel tirar partido dos mecanismos de m\u00faltiplas threads numa
programa.<\/p>\n\n\n\n

Execut\u00e1vel<\/h3>\n\n\n\n

Linha<\/code> \u00e9 um Java<\/strong> na qual a magia acontece. Esta \u00e9 a representa\u00e7\u00e3o do objeto da thread mencionada anteriormente. Para
criar o seu pr\u00f3prio thread, pode estender o Linha<\/code> classe. No entanto, esta n\u00e3o \u00e9 uma abordagem recomendada. Fios<\/code> deve ser utilizado como um mecanismo para executar a tarefa. As tarefas s\u00e3o partes de c\u00f3digo<\/a> que queremos executar num modo concorrente. Podemos defini-los utilizando a fun\u00e7\u00e3o Execut\u00e1vel<\/code> interface.<\/p>\n\n\n\n

Mas chega de teoria, vamos p\u00f4r o nosso c\u00f3digo onde est\u00e1 a nossa boca.<\/p>\n\n\n\n

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

Suponhamos que temos um par de matrizes de n\u00fameros. Para cada matriz, queremos saber a soma dos n\u00fameros numa matriz. Vamos
\u00c9 suposto que existam muitas destas matrizes e que cada uma delas seja relativamente grande. Nessas condi\u00e7\u00f5es, queremos utilizar a concorr\u00eancia e somar cada matriz como uma tarefa separada.<\/p>\n\n\n\n

int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10};\nint[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};\n\nRunnable task1 = () -> {\n    int soma = Arrays.stream(a1).soma();\n    System.out.println(\"1. A soma \u00e9: \" + soma);\n};\n\nRunnable task2 = () -> {\n    int sum = Arrays.stream(a2).sum();\n    System.out.println(\"2. A soma \u00e9: \" + soma);\n};\n\nRunnable task3 = () -> {\n    int sum = Arrays.stream(a3).sum();\n    System.out.println(\"3. A soma \u00e9: \" + soma);\n};\n\nnova Thread(task1).start();\nnova Thread(tarefa2).start();\nnew Thread(task3).start();<\/code><\/pre>\n\n\n\n
Como pode ver no c\u00f3digo acima Execut\u00e1vel<\/code> \u00e9 uma interface funcional. Cont\u00e9m um \u00fanico m\u00e9todo abstrato executar()<\/code>
sem argumentos. O Execut\u00e1vel<\/code> deve ser implementada por qualquer classe cujas inst\u00e2ncias se destinem a ser
executada por um thread.<\/p>\n\n\n\n
Depois de definir uma tarefa, pode criar um segmento para a executar. Isto pode ser feito atrav\u00e9s de novo Thread()<\/code> construtor que
toma Execut\u00e1vel<\/code> como seu argumento.<\/p>\n\n\n\n
O \u00faltimo passo \u00e9 iniciar()<\/code> um novo t\u00f3pico criado. No API<\/a> existem tamb\u00e9m executar()<\/code> m\u00e9todos em Execut\u00e1vel<\/code> e em
Linha<\/code>. No entanto, essa n\u00e3o \u00e9 uma forma de aproveitar a concorr\u00eancia em Java. Uma chamada direta a cada um destes m\u00e9todos resulta em
executando a tarefa no mesmo thread que o principal()<\/code> m\u00e9todo \u00e9 executado.<\/p>\n\n\n\n
Grupos de threads e executores<\/h3>\n\n\n\n
Quando existem muitas tarefas, criar um thread separado para cada uma n\u00e3o \u00e9 uma boa ideia. Criar uma Linha<\/code> \u00e9 um
opera\u00e7\u00e3o pesada e \u00e9 muito melhor reutilizar os fios existentes do que criar novos.<\/p>\n\n\n\n
Quando um programa cria muitos threads de curta dura\u00e7\u00e3o, \u00e9 melhor usar um pool de threads. O pool de threads cont\u00e9m um n\u00famero de
t\u00f3picos prontos para serem executados mas atualmente n\u00e3o activos. Dando um Execut\u00e1vel<\/code> para o pool faz com que uma das threads chame a fun\u00e7\u00e3o
executar()<\/code> m\u00e9todo de um determinado Execut\u00e1vel<\/code>. Ap\u00f3s a conclus\u00e3o de uma tarefa, o segmento continua a existir e est\u00e1 num estado inativo.<\/p>\n\n\n\n
Ok, j\u00e1 percebeu - prefira o pool de threads em vez da cria\u00e7\u00e3o manual. Mas como \u00e9 que se pode utilizar os pools de threads? O Executores<\/code>
tem uma s\u00e9rie de m\u00e9todos est\u00e1ticos de f\u00e1brica para construir pools de threads. Por exemplo newCachedThredPool()<\/code> cria
uma piscina na qual s\u00e3o criadas novas threads conforme necess\u00e1rio e as threads inactivas s\u00e3o mantidas durante 60 segundos. Em contrapartida,
newFixedThreadPool()<\/code> cont\u00e9m um conjunto fixo de threads, no qual as threads inactivas s\u00e3o mantidas indefinidamente.<\/p>\n\n\n\n
Vejamos como pode funcionar no nosso exemplo. Agora n\u00e3o precisamos de criar threads manualmente. Em vez disso, temos de criar
ExecutorService<\/code> que fornece um conjunto de threads. Em seguida, podemos atribuir-lhe tarefas. O \u00faltimo passo \u00e9 fechar a thread
para evitar fugas de mem\u00f3ria. O resto do c\u00f3digo anterior permanece o mesmo.<\/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
Acess\u00edvel<\/h3>\n\n\n\n
Execut\u00e1vel<\/code> parece ser uma forma elegante de criar tarefas concorrentes, mas tem uma grande falha. Ele n\u00e3o pode retornar nenhum
valor. Al\u00e9m disso, n\u00e3o podemos determinar se uma tarefa est\u00e1 conclu\u00edda ou n\u00e3o. Tamb\u00e9m n\u00e3o sabemos se foi conclu\u00edda
normal ou excecionalmente. A solu\u00e7\u00e3o para estes males \u00e9 Acess\u00edvel<\/code>.<\/p>\n\n\n\n
Acess\u00edvel<\/code> \u00e9 semelhante a Execut\u00e1vel<\/code> de certa forma, tamb\u00e9m envolve tarefas ass\u00edncronas. A principal diferen\u00e7a \u00e9 que ele \u00e9 capaz de
devolver um valor. O valor de retorno pode ser de qualquer tipo (n\u00e3o primitivo) como o Acess\u00edvel<\/code> \u00e9 um tipo parametrizado.
Acess\u00edvel<\/code> \u00e9 uma interface funcional que tem chamar()<\/code> que pode lan\u00e7ar um m\u00e9todo Exce\u00e7\u00e3o<\/code>.<\/p>\n\n\n\n
Agora vamos ver como podemos aproveitar Acess\u00edvel<\/code> no nosso problema da matriz.<\/p>\n\n\n\n
int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};\nint[] a2 = {10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 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. A soma \u00e9: \" + future1.get());\nSystem.out.println(\"2. A soma \u00e9: \" + future2.get());\nSystem.out.println(\"3. A soma \u00e9: \" + future3.get());\n\nexecutor.shutdown();<\/code><\/pre>\n\n\n\n
Ok, podemos ver como Acess\u00edvel<\/code> \u00e9 criado e depois apresentado ao ExecutorService<\/code>. Mas o que raio \u00e9 Futuro<\/code>?
Futuro<\/code> actua como uma ponte entre threads. A soma de cada matriz \u00e9 produzida numa thread separada e precisamos de uma forma de
obter esses resultados de volta para principal()<\/code>.<\/p>\n\n\n\n
Para obter o resultado de Futuro<\/code> precisamos de chamar get()<\/code> m\u00e9todo. Aqui pode acontecer uma de duas coisas. Primeiro, o
resultado do c\u00e1lculo efectuado por Acess\u00edvel<\/code> estiver dispon\u00edvel. Ent\u00e3o, recebemo-lo imediatamente. Em segundo lugar, o resultado n\u00e3o \u00e9
j\u00e1 est\u00e1 pronto. Neste caso get()<\/code> ir\u00e1 bloquear at\u00e9 que o resultado esteja dispon\u00edvel.<\/p>\n\n\n\n
ComputableFuture<\/h3>\n\n\n\n
O problema com Futuro<\/code> \u00e9 o facto de funcionar segundo o \"paradigma push\". Ao utilizar Futuro<\/code> tem de ser como um chefe que
pergunta constantemente: \"A sua tarefa est\u00e1 conclu\u00edda? Est\u00e1 pronta?\" at\u00e9 obter um resultado. Atuar sob press\u00e3o constante \u00e9
caro. Uma abordagem muito melhor seria encomendar Futuro<\/code> o que fazer quando estiver pronto para a sua tarefa. Infelizmente,
Futuro<\/code> n\u00e3o pode fazer isso, mas ComputableFuture<\/code> pode.<\/p>\n\n\n\n
ComputableFuture<\/code> funciona no 'paradigma pull'. Podemos dizer-lhe o que fazer com o resultado quando tiver conclu\u00eddo as suas tarefas. O
\u00e9 um exemplo de uma abordagem ass\u00edncrona.<\/p>\n\n\n\n
ComputableFuture<\/code> funciona perfeitamente com Execut\u00e1vel<\/code> mas n\u00e3o com Acess\u00edvel<\/code>. Em vez disso, \u00e9 poss\u00edvel fornecer uma tarefa ao
ComputableFuture<\/code> sob a forma de Fornecedor<\/code>.<\/p>\n\n\n\n
Vejamos como o que foi dito acima se relaciona com o nosso 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, 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
A primeira coisa que nos chama a aten\u00e7\u00e3o \u00e9 o facto de esta solu\u00e7\u00e3o ser muito mais curta. Para al\u00e9m disso, tamb\u00e9m tem um aspeto limpo e arrumado.<\/p>\n\n\n\n
Tarefa para CompletableFuture<\/code> pode ser fornecido por supplyAsync()<\/code> m\u00e9todo que recebe Fornecedor<\/code> ou por runAsync()<\/code> que
toma Execut\u00e1vel<\/code>. Um retorno de chamada - um peda\u00e7o de c\u00f3digo que deve ser executado na conclus\u00e3o da tarefa - \u00e9 definido por thenAccept()<\/code>
m\u00e9todo.<\/p>\n\n\n\n
Conclus\u00f5es<\/h2>\n\n\n\n
Java<\/strong> fornece muitas abordagens diferentes para a concorr\u00eancia. Neste artigo, mal toc\u00e1mos no assunto.<\/p>\n\n\n\n
No entanto, abord\u00e1mos as no\u00e7\u00f5es b\u00e1sicas de Linha<\/code>, Execut\u00e1vel<\/code>, Acess\u00edvel<\/code>e CallableFuture<\/code> o que coloca uma boa quest\u00e3o
para uma investiga\u00e7\u00e3o mais aprofundada do tema.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
Leia a primeira parte da nossa s\u00e9rie de blogues dedicada \u00e0 concorr\u00eancia em Java. No artigo a seguir, veremos mais de perto as diferen\u00e7as entre thread e processos, pools de threads, executores e muito mais!<\/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\/pt\/blogue\/concorrencia-em-java-parte-1-introducao\/\" \/>\n<meta property=\"og:locale\" content=\"pt_PT\" \/>\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\/pt\/blogue\/concorrencia-em-java-parte-1-introducao\/\" \/>\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\":\"pt-PT\",\"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\":\"pt-PT\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"pt-PT\",\"@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\":\"pt-PT\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"pt-PT\",\"@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\":\"pt-PT\",\"@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\\\/pt\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Concorr\u00eancia em Java Parte 1 - Introdu\u00e7\u00e3o - The Codest","description":"Leia a primeira parte da nossa s\u00e9rie de blogues dedicada \u00e0 concorr\u00eancia em 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\/pt\/blogue\/concorrencia-em-java-parte-1-introducao\/","og_locale":"pt_PT","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\/pt\/blogue\/concorrencia-em-java-parte-1-introducao\/","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":"pt-PT","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":"Concorr\u00eancia em Java Parte 1 - Introdu\u00e7\u00e3o - 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":"Leia a primeira parte da nossa s\u00e9rie de blogues dedicada \u00e0 concorr\u00eancia em Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"pt-PT","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"pt-PT","@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":"pt-PT"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"The Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"pt-PT","@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":"pt-PT","@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\/pt\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/pt\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}