{"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":"concurrencia-en-java-parte-1-introduccion","status":"publish","type":"post","link":"https:\/\/thecodest.co\/es\/blog\/concurrency-in-java-part-1-introduction\/","title":{"rendered":"Concurrencia en Java Parte 1 - Introducci\u00f3n"},"content":{"rendered":"

En general, el enfoque de programaci\u00f3n convencional es secuencial. Todo en un programa ocurre paso a paso.
Pero, de hecho, el paralelo es c\u00f3mo funciona el mundo entero: es la capacidad de ejecutar m\u00e1s de una tarea simult\u00e1neamente.<\/p>\n\n\n\n

Hilo conductor vs. proceso<\/h2>\n\n\n\n

Para debatir temas avanzados como concurrencia en Java<\/a><\/strong> o multihilo, tenemos que establecer algunas definiciones comunes para estar seguros de que estamos en la misma p\u00e1gina.<\/p>\n\n\n\n

Empecemos por lo b\u00e1sico. En el mundo no secuencial, tenemos dos tipos de representantes de concurrencia: procesos y
hilos. Un proceso es una instancia del programa en ejecuci\u00f3n. Normalmente, est\u00e1 aislado de otros procesos.
El sistema operativo se encarga de asignar recursos a cada proceso. Adem\u00e1s, act\u00faa como un conductor que
los programa y los controla.<\/p>\n\n\n\n

Un hilo es una especie de proceso pero a un nivel inferior, por lo que tambi\u00e9n se conoce como hilo ligero. M\u00faltiples hilos pueden ejecutarse en un
proceso. Aqu\u00ed el programa act\u00faa como planificador y controlador de hilos. De esta forma los programas individuales parecen hacer
m\u00faltiples tareas al mismo tiempo.<\/p>\n\n\n\n

La diferencia fundamental entre hilos y procesos es el nivel de aislamiento. El proceso tiene su propio conjunto de
recursos, mientras que el hilo comparte datos<\/a> con otros hilos. Puede parecer un enfoque propenso a errores y, de hecho, lo es. En
Ahora, no vamos a centrarnos en eso, ya que est\u00e1 fuera del alcance de este art\u00edculo.<\/p>\n\n\n\n

Procesos, hilos... Vale... Pero, \u00bfqu\u00e9 es exactamente la concurrencia? Concurrencia significa que se pueden ejecutar varias tareas al mismo tiempo.
tiempo. No significa que esas tareas tengan que ejecutarse simult\u00e1neamente: eso es el paralelismo. Concurrenc en Javay<\/strong> tampoco
requieren disponer de varias CPU o incluso de varios n\u00facleos. Se puede conseguir en un entorno de un solo n\u00facleo aprovechando
cambio de contexto.<\/p>\n\n\n\n

Un t\u00e9rmino relacionado con la concurrencia es multithreading. Se trata de una caracter\u00edstica de los programas que les permite ejecutar varias tareas a la vez. No todos los programas utilizan este enfoque, pero los que lo hacen pueden denominarse multihilo.<\/p>\n\n\n\n

Ya casi estamos listos, s\u00f3lo falta una definici\u00f3n. Asincron\u00eda significa que un programa realiza operaciones no bloqueantes.
Inicia una tarea y luego sigue con otras cosas mientras espera la respuesta. Cuando recibe la respuesta, puede reaccionar<\/a> a ella.<\/p>\n\n\n\n

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

Por defecto, cada Aplicaci\u00f3n Java<\/strong> se ejecuta en un proceso. En ese proceso, hay un hilo relacionado con el main()<\/code> m\u00e9todo de
una aplicaci\u00f3n. Sin embargo, como se ha mencionado, es posible aprovechar los mecanismos de m\u00faltiples hilos dentro de una
programa.<\/p>\n\n\n\n

Ejecutable<\/h3>\n\n\n\n

Hilo<\/code> es un Java<\/strong> en la que ocurre la magia. Esta es la representaci\u00f3n del objeto del hilo antes mencionado. Para
crear su propio hilo, puede ampliar el Hilo<\/code> clase. Sin embargo, no es un enfoque recomendable. Hilos<\/code> como mecanismo que ejecuta la tarea. Las tareas son piezas de c\u00f3digo<\/a> que queremos ejecutar en modo concurrente. Podemos definirlos utilizando la funci\u00f3n Ejecutable<\/code> interfaz.<\/p>\n\n\n\n

Pero basta de teor\u00eda, pongamos nuestro c\u00f3digo donde est\u00e1 nuestra boca.<\/p>\n\n\n\n

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

Supongamos que tenemos un par de matrices de n\u00fameros. Para cada matriz, queremos saber la suma de los n\u00fameros de una matriz. Supongamos
Imaginemos que hay muchas matrices de este tipo y que cada una de ellas es relativamente grande. En tales condiciones, queremos hacer uso de la concurrencia y sumar cada matriz como una tarea independiente.<\/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};\nint[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};\n\nTarea ejecutable1 = () -> {\n    int suma = Arrays.stream(a1).suma();\n    System.out.println(\"1. La suma es: \" + suma);\n};\n\nTarea ejecutable2 = () -> {\n    int suma = Arrays.stream(a2).suma();\n    System.out.println(\"2. La suma es: \" + suma);\n};\n\nRunnable tarea3 = () -> {\n    int suma = Arrays.stream(a3).suma();\n    System.out.println(\"3. La suma es: \" + suma);\n};\n\nnuevo Thread(tarea1).start();\nnuevo subproceso(tarea2).start();\nnew Thread(task3).start();<\/code><\/pre>\n\n\n\n
Como puede verse en el c\u00f3digo anterior Ejecutable<\/code> es una interfaz funcional. Contiene un \u00fanico m\u00e9todo abstracto ejecutar()<\/code>
sin argumentos. La direcci\u00f3n Ejecutable<\/code> debe ser implementada por cualquier clase cuyas instancias est\u00e9n destinadas a ser
ejecutado por un hilo.<\/p>\n\n\n\n
Una vez definida una tarea, puede crear un subproceso para ejecutarla. Esto puede hacerse mediante nuevo Hilo()<\/code> constructor que
toma Ejecutable<\/code> como argumento.<\/p>\n\n\n\n
El \u00faltimo paso es iniciar()<\/code> un hilo reci\u00e9n creado. En el API<\/a> tambi\u00e9n hay ejecutar()<\/code> m\u00e9todos en Ejecutable<\/code> y en
Hilo<\/code>. Sin embargo, esa no es una forma de aprovechar la concurrencia en Java. Una llamada directa a cada uno de estos m\u00e9todos resulta en
ejecutando la tarea en el mismo hilo que el main()<\/code> se ejecuta el m\u00e9todo.<\/p>\n\n\n\n
Thread pools y Ejecutores<\/h3>\n\n\n\n
Cuando hay muchas tareas, crear un hilo separado para cada una no es una buena idea. Crear un Hilo<\/code> es un
operaci\u00f3n pesada y es mucho mejor reutilizar los hilos existentes que crear otros nuevos.<\/p>\n\n\n\n
Cuando un programa crea muchos hilos de corta duraci\u00f3n es mejor utilizar un pool de hilos. El pool de hilos contiene un n\u00famero de
hilos listos para ejecutarse pero actualmente no activos. Dando un Ejecutable<\/code> al pool hace que uno de los hilos llame a la funci\u00f3n
ejecutar()<\/code> m\u00e9todo de dado Ejecutable<\/code>. Tras completar una tarea, el hilo sigue existiendo y se encuentra en estado inactivo.<\/p>\n\n\n\n
De acuerdo, ya lo has entendido: prefiere los thread pools a la creaci\u00f3n manual. Pero, \u00bfc\u00f3mo se pueden utilizar los thread pools? El Ejecutores<\/code>
tiene una serie de m\u00e9todos de f\u00e1brica est\u00e1ticos para construir pools de hilos. Por ejemplo newCachedThredPool()<\/code> crea
un pool en el que se crean nuevos hilos seg\u00fan sea necesario y los hilos inactivos se mantienen durante 60 segundos. Por el contrario,
newFixedThreadPool()<\/code> contiene un conjunto fijo de hilos, en el que los hilos ociosos se mantienen indefinidamente.<\/p>\n\n\n\n
Veamos c\u00f3mo podr\u00eda funcionar en nuestro ejemplo. Ahora no necesitamos crear hilos manualmente. En su lugar, tenemos que crear
Servicio de ejecutor<\/code> que proporciona un pool de hilos. A continuaci\u00f3n, podemos asignarle tareas. El \u00faltimo paso es cerrar el hilo
para evitar p\u00e9rdidas de memoria. El resto del c\u00f3digo anterior permanece igual.<\/p>\n\n\n\n
ExecutorService executor = Executors.newCachedThreadPool();\n\nexecutor.submit(task1);\nexecutor.submit(task2);\nexecutor.submit(task3);\n\nejecutor.shutdown();<\/code><\/pre>\n\n\n\n
Llamable<\/h3>\n\n\n\n
Ejecutable<\/code> parece una forma ingeniosa de crear tareas concurrentes, pero tiene un defecto importante. No puede devolver ning\u00fan
valor. Es m\u00e1s, no podemos determinar si una tarea est\u00e1 terminada o no. Tampoco sabemos si se ha completado
normal o excepcional. La soluci\u00f3n a esos males es Llamable<\/code>.<\/p>\n\n\n\n
Llamable<\/code> es similar a Ejecutable<\/code> en cierto modo tambi\u00e9n envuelve tareas as\u00edncronas. La principal diferencia es que es capaz de
devuelven un valor. El valor devuelto puede ser de cualquier tipo (no primitivo), ya que la funci\u00f3n Llamable<\/code> es un tipo parametrizado.
Llamable<\/code> es una interfaz funcional que tiene llamar()<\/code> que puede lanzar un Excepci\u00f3n<\/code>.<\/p>\n\n\n\n
Ahora vamos a ver c\u00f3mo podemos aprovechar Llamable<\/code> en nuestro problema de matrices.<\/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};\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();\nFuturo future1 = executor.submit(task1);\nFuturo future2 = executor.submit(task2);\nFuture future3 = executor.submit(task3);\n\nSystem.out.println(\"1. La suma es: \" + future1.get());\nSystem.out.println(\"2. La suma es: \" + future2.get());\nSystem.out.println(\"3. La suma es: \" + future3.get());\n\nejecutor.shutdown();<\/code><\/pre>\n\n\n\n
Bien, podemos ver c\u00f3mo Llamable<\/code> y se env\u00eda a Servicio de ejecutor<\/code>. Pero, \u00bfqu\u00e9 diablos es Futuro<\/code>?
Futuro<\/code> act\u00faa como puente entre hilos. La suma de cada matriz se produce en un hilo separado y necesitamos una forma de
devolver esos resultados a main()<\/code>.<\/p>\n\n\n\n
Para recuperar el resultado de Futuro<\/code> necesitamos llamar a get()<\/code> m\u00e9todo. Aqu\u00ed puede ocurrir una de dos cosas. En primer lugar, el
resultado del c\u00e1lculo realizado por Llamable<\/code> est\u00e1 disponible. Entonces lo obtenemos inmediatamente. En segundo lugar, el resultado no es
listo todav\u00eda. En ese caso get()<\/code> se bloquear\u00e1 hasta que el resultado est\u00e9 disponible.<\/p>\n\n\n\n
Futuro computable<\/h3>\n\n\n\n
El problema con Futuro<\/code> es que funciona en el \"paradigma push\". Cuando se utiliza Futuro<\/code> tienes que ser como un jefe que
pregunta constantemente: '\u00bfEst\u00e1 hecha la tarea? \u00bfEst\u00e1 lista?\" hasta que ofrezca un resultado. Actuar bajo una presi\u00f3n constante es
caro. Mucho mejor ser\u00eda pedir Futuro<\/code> qu\u00e9 hacer cuando est\u00e9 preparado para su tarea. Desgraciadamente,
Futuro<\/code> no puede hacerlo sino Futuro computable<\/code> puede.<\/p>\n\n\n\n
Futuro computable<\/code> funciona en el \"paradigma pull\". Podemos decirle qu\u00e9 hacer con el resultado cuando haya completado sus tareas. En
es un ejemplo de enfoque as\u00edncrono.<\/p>\n\n\n\n
Futuro computable<\/code> funciona perfectamente con Ejecutable<\/code> pero no con Llamable<\/code>. En su lugar, es posible suministrar una tarea a
Futuro computable<\/code> en forma de Proveedor<\/code>.<\/p>\n\n\n\n
Veamos c\u00f3mo se relaciona lo anterior con nuestro 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};\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
Lo primero que llama la atenci\u00f3n es lo corta que es esta soluci\u00f3n. Adem\u00e1s, tambi\u00e9n tiene un aspecto limpio y ordenado.<\/p>\n\n\n\n
Tarea a CompletableFuture<\/code> puede ser proporcionada por supplyAsync()<\/code> que toma Proveedor<\/code> o por runAsync()<\/code> que
toma Ejecutable<\/code>. Una llamada de retorno - un fragmento de c\u00f3digo que debe ejecutarse al finalizar la tarea - se define mediante thenAccept()<\/code>
m\u00e9todo.<\/p>\n\n\n\n
Conclusiones<\/h2>\n\n\n\n
Java<\/strong> proporciona una gran cantidad de enfoques diferentes para la concurrencia. En este art\u00edculo, apenas hemos tocado el tema.<\/p>\n\n\n\n
No obstante, hemos cubierto los aspectos b\u00e1sicos de Hilo<\/code>, Ejecutable<\/code>, Llamable<\/code>y CallableFuture<\/code> que plantea una buena cuesti\u00f3n
para seguir investigando el tema.<\/p>\n\n\n\n
\"\"<\/a><\/figure>","protected":false},"excerpt":{"rendered":"
Lea la primera parte de nuestra serie de blogs dedicada a la concurrencia en Java. En el siguiente art\u00edculo vamos a echar un vistazo m\u00e1s de cerca a las diferencias entre hilos y procesos, pools de hilos, ejecutores y \u00a1mucho m\u00e1s!<\/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\/es\/blog\/concurrencia-en-java-parte-1-introduccion\/\" \/>\n<meta property=\"og:locale\" content=\"es_ES\" \/>\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\/es\/blog\/concurrencia-en-java-parte-1-introduccion\/\" \/>\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\":\"es-ES\",\"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\":\"es-ES\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/thecodest.co\\\/blog\\\/concurrency-in-java-part-1-introduction\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"es-ES\",\"@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\":\"es-ES\"},{\"@type\":\"Organization\",\"@id\":\"https:\\\/\\\/thecodest.co\\\/#organization\",\"name\":\"The Codest\",\"url\":\"https:\\\/\\\/thecodest.co\\\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"es-ES\",\"@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\":\"es-ES\",\"@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\\\/es\\\/author\\\/thecodest\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO Premium plugin. -->","yoast_head_json":{"title":"Concurrencia en Java Parte 1 - Introducci\u00f3n - The Codest","description":"Lea la primera parte de nuestra serie de blogs dedicada a la concurrencia 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\/es\/blog\/concurrencia-en-java-parte-1-introduccion\/","og_locale":"es_ES","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\/es\/blog\/concurrencia-en-java-parte-1-introduccion\/","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":"es-ES","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":"Concurrencia en Java Parte 1 - Introducci\u00f3n - 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":"Lea la primera parte de nuestra serie de blogs dedicada a la concurrencia en Java.","breadcrumb":{"@id":"https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/#breadcrumb"},"inLanguage":"es-ES","potentialAction":[{"@type":"ReadAction","target":["https:\/\/thecodest.co\/blog\/concurrency-in-java-part-1-introduction\/"]}]},{"@type":"ImageObject","inLanguage":"es-ES","@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":"es-ES"},{"@type":"Organization","@id":"https:\/\/thecodest.co\/#organization","name":"The Codest","url":"https:\/\/thecodest.co\/","logo":{"@type":"ImageObject","inLanguage":"es-ES","@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":"es-ES","@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\/es\/author\/thecodest\/"}]}},"_links":{"self":[{"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/posts\/3138","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/comments?post=3138"}],"version-history":[{"count":8,"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/posts\/3138\/revisions"}],"predecessor-version":[{"id":8551,"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/posts\/3138\/revisions\/8551"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/media\/3139"}],"wp:attachment":[{"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/media?parent=3138"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/categories?post=3138"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/thecodest.co\/es\/wp-json\/wp\/v2\/tags?post=3138"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}