[{"data":1,"prerenderedAt":2053},["ShallowReactive",2],{"navigation_docs":3,"-concurrencia-thread-runnable":298,"-concurrencia-thread-runnable-surround":2048},[4,18,70,105,149,178,212,257],{"title":5,"path":6,"stem":7,"children":8,"icon":17},"Evaluación","\u002Fintroduction","1.introduction\u002F1.index",[9,12],{"title":10,"path":6,"stem":7,"icon":11},"Método de Evaluación","i-iconamoon-cheque-bold",{"title":13,"path":14,"stem":15,"icon":16},"Plataforma de Aprendizaje","\u002Fintroduction\u002Fplataforma","1.introduction\u002F2.plataforma","i-lucide-book-marked","i-lucide-house",{"title":19,"path":20,"stem":21,"children":22,"icon":25},"Interfaz Gráfica de Usuario","\u002Fgui","2.gui\u002F01.index",[23,26,30,34,38,42,46,50,54,58,62,66],{"title":24,"path":20,"stem":21,"icon":25},"¿Qué es una Interfaz Gráfica de Usuario (GUI)?","i-carbon-gui-management",{"title":27,"path":28,"stem":29,"icon":25},"Creación de Interfaces Gráficas de Usuario (GUI)","\u002Fgui\u002Fbuild-gui","2.gui\u002F02.build-gui",{"title":31,"path":32,"stem":33,"icon":25},"Componentes Básicos de Swing","\u002Fgui\u002Fcomponentes-basicos","2.gui\u002F03.componentes-basicos",{"title":35,"path":36,"stem":37},"El componente JFrame","\u002Fgui\u002Fjframe","2.gui\u002F04.jframe",{"title":39,"path":40,"stem":41},"El componente JPanel","\u002Fgui\u002Fjpanel","2.gui\u002F05.jpanel",{"title":43,"path":44,"stem":45},"El componente JButton","\u002Fgui\u002Fjbutton","2.gui\u002F06.jbutton",{"title":47,"path":48,"stem":49,"icon":25},"Elementos de texto en interfaces gráficas con Swing","\u002Fgui\u002Ftext","2.gui\u002F07.text",{"title":51,"path":52,"stem":53},"Elementos Visuales","\u002Fgui\u002Felementos-visuales","2.gui\u002F08.elementos-visuales",{"title":55,"path":56,"stem":57,"icon":25},"Eventos en Swing","\u002Fgui\u002Feventos","2.gui\u002F09.eventos",{"title":59,"path":60,"stem":61,"icon":25},"Controles en Swing","\u002Fgui\u002Fcontroles","2.gui\u002F10.controles",{"title":63,"path":64,"stem":65,"icon":25},"Atributos Comunes de los Componentes de Diseño","\u002Fgui\u002Fatributos-comunes","2.gui\u002F11.atributos-comunes",{"title":67,"path":68,"stem":69,"icon":25},"Layouts","\u002Fgui\u002Flayout","2.gui\u002F12.layout",{"title":71,"icon":25,"path":72,"stem":73,"children":74,"page":104},"Personalización","\u002Fpersonalizacion","3.personalizacion",[75,79,84,88,92,96,100],{"title":76,"path":77,"stem":78},"Jerarquía de clases en Swing","\u002Fpersonalizacion\u002Fjerarquia","3.personalizacion\u002F01.jerarquia",{"title":80,"path":81,"stem":82,"icon":83},"Personalización Inicial de Componentes Swing","\u002Fpersonalizacion\u002Fpersonalizacion-inicial","3.personalizacion\u002F02.personalizacion-inicial","i-carbon-palette",{"title":85,"path":86,"stem":87,"icon":83},"Tema y Personalización Avanzada en Swing","\u002Fpersonalizacion\u002Ftheme","3.personalizacion\u002F03.theme",{"title":89,"path":90,"stem":91,"icon":83},"Pintando en Swing","\u002Fpersonalizacion\u002Fpaint","3.personalizacion\u002F04.paint",{"title":93,"path":94,"stem":95,"icon":83},"Mi Tema 1: Comenzando con la Personalización","\u002Fpersonalizacion\u002Ftheme-start","3.personalizacion\u002F05.theme-start",{"title":97,"path":98,"stem":99,"icon":83},"UI Delegates: Personalizando la Apariencia de los Componentes","\u002Fpersonalizacion\u002Fui-delegates","3.personalizacion\u002F06.ui-delegates",{"title":101,"path":102,"stem":103,"icon":83},"Empleado delegadores de UI para personalizar la apariencia de los componentes","\u002Fpersonalizacion\u002Ftheme-02","3.personalizacion\u002F07.theme-02",false,{"title":106,"path":107,"stem":108,"children":109,"icon":148},"Programación concurrente","\u002Fconcurrencia","4.concurrencia\u002F01.index",[110,112,116,120,124,128,132,136,140,144],{"title":111,"path":107,"stem":108,"icon":83},"¿Qué es la concurrencia?",{"title":113,"path":114,"stem":115,"icon":83},"Unidades de Ejecución","\u002Fconcurrencia\u002Funidades-ejecucion","4.concurrencia\u002F02.unidades-ejecucion",{"title":117,"path":118,"stem":119,"icon":83},"Programa de flujo único y de flujo múltiple","\u002Fconcurrencia\u002Fflujos","4.concurrencia\u002F03.flujos",{"title":121,"path":122,"stem":123,"icon":83},"Hilos con Thread y Runnable","\u002Fconcurrencia\u002Fthread-runnable","4.concurrencia\u002F04.thread-runnable",{"title":125,"path":126,"stem":127},"Paralelismo V.S. Concurrencia","\u002Fconcurrencia\u002Fparalelismo","4.concurrencia\u002F05.paralelismo",{"title":129,"path":130,"stem":131,"icon":83},"Problemas clásicos de concurrencia","\u002Fconcurrencia\u002Fproblemas","4.concurrencia\u002F06.problemas",{"title":133,"path":134,"stem":135,"icon":83},"Emulando condiciones de carrera en Java","\u002Fconcurrencia\u002Fcondiciones-carrera","4.concurrencia\u002F07.condiciones-carrera",{"title":137,"path":138,"stem":139,"icon":83},"Semáforos en Java","\u002Fconcurrencia\u002Fsemaforos","4.concurrencia\u002F08.semaforos",{"title":141,"path":142,"stem":143,"icon":83},"La clase Timer en Java Swing","\u002Fconcurrencia\u002Ftimer","4.concurrencia\u002F09.timer",{"title":145,"path":146,"stem":147,"icon":83},"Algoritmos de ordenamiento de procesos","\u002Fconcurrencia\u002Falgoritmos-procesos","4.concurrencia\u002F10.algoritmos-procesos","i-carbon-parallel-groups",{"title":150,"path":151,"stem":152,"children":153,"icon":177},"Acceso a datos","\u002Fdatos","5.datos\u002F01.index",[154,157,161,165,169,173],{"title":155,"path":151,"stem":152,"icon":156},"Java y las bases de datos","i-carbon-database",{"title":158,"path":159,"stem":160},"Cliente Servidor","\u002Fdatos\u002Fcliente-servidor","5.datos\u002F02.cliente-servidor",{"title":162,"path":163,"stem":164},"CRUD","\u002Fdatos\u002Fcrud","5.datos\u002F03.crud",{"title":166,"path":167,"stem":168},"Sentencias Preparadas con JDBC","\u002Fdatos\u002Fsentencia-preparada","5.datos\u002F04.sentencia-preparada",{"title":170,"path":171,"stem":172},"DAO (Data Access Object)","\u002Fdatos\u002Fdao","5.datos\u002F05.dao",{"title":174,"path":175,"stem":176},"Usando Hibernate ORM","\u002Fdatos\u002Form","5.datos\u002F06.orm","i-gravity-ui-database-fill",{"title":179,"path":180,"stem":181,"children":182,"icon":211},"Programación móvil","\u002Fmovil","6.movil\u002F01.index",[183,186,191,195,199,203,207],{"title":184,"path":180,"stem":181,"icon":185},"¿Qué es Android y Kotlin?","i-carbon-mobile",{"title":187,"path":188,"stem":189,"icon":190},"¿Qué es Android Studio?","\u002Fmovil\u002Fandroid-studio","6.movil\u002F02.android-studio","i-carbon-application",{"title":192,"path":193,"stem":194,"icon":190},"¿Qué es Jetpack Compose?","\u002Fmovil\u002Fjetpack-compose","6.movil\u002F03.jetpack-compose",{"title":196,"path":197,"stem":198},"Filas y Columnas con Jetpack Compose","\u002Fmovil\u002Ffilas-columnas","6.movil\u002F04.filas-columnas",{"title":200,"path":201,"stem":202,"icon":190},"Componentes Básicos en Jetpack Compose","\u002Fmovil\u002Fcomponentes-basicos","6.movil\u002F05.componentes-basicos",{"title":204,"path":205,"stem":206,"icon":190},"Las Intenciones en Android con Jetpack Compose","\u002Fmovil\u002Fintentions","6.movil\u002F06.intentions",{"title":208,"path":209,"stem":210,"icon":190},"Navegación en Android con Jetpack Compose","\u002Fmovil\u002Fnavegacion","6.movil\u002F07.navegacion","phone_android",{"title":213,"icon":25,"path":214,"stem":215,"children":216,"page":104},"Ejemplos","\u002Fejemplos","7.ejemplos",[217,221,225,229,233,237,241,245,249,253],{"title":218,"path":219,"stem":220},"Ejemplo 01: Creando un validador abstracto de expresiones","\u002Fejemplos\u002Fejemplo-01","7.ejemplos\u002F01.ejemplo-01",{"title":222,"path":223,"stem":224},"Ejemplo 02: Diferencias de validar un JTextField y un JFormattedTextField","\u002Fejemplos\u002Fejemplo-02","7.ejemplos\u002F02.ejemplo-02",{"title":226,"path":227,"stem":228},"Ejemplo 03: Creando una Aplicación con GUI en Java Swing","\u002Fejemplos\u002Fejemplo-03","7.ejemplos\u002F03.ejemplo-03",{"title":230,"path":231,"stem":232},"Ejemplo 4: Estilizando componentes Swing con Delegadores","\u002Fejemplos\u002Fejemplo-04","7.ejemplos\u002F04.ejemplo-04",{"title":234,"path":235,"stem":236,"icon":83},"Ejemplo 5: Uso de Hilos con Thread y Runnable","\u002Fejemplos\u002Fejemplo-05","7.ejemplos\u002F05.ejemplo-05",{"title":238,"path":239,"stem":240,"icon":83},"Ejemplo 06: Manejando Hilos de formas Diferentes en Java","\u002Fejemplos\u002Fejemplo-06","7.ejemplos\u002F06.ejemplo-06",{"title":242,"path":243,"stem":244,"icon":83},"Ejemplo 7: Condiciones de carrera en Java","\u002Fejemplos\u002Fejemplo-07","7.ejemplos\u002F07.ejemplo-07",{"title":246,"path":247,"stem":248,"icon":83},"Ejemplo 8: Control de acceso a recursos compartidos con semáforos","\u002Fejemplos\u002Fejemplo-08","7.ejemplos\u002F08.ejemplo-08",{"title":250,"path":251,"stem":252,"icon":83},"Ejemplo 9: El restaurante y los pedidos","\u002Fejemplos\u002Fejemplo-09","7.ejemplos\u002F09.ejemplo-09",{"title":254,"path":255,"stem":256},"Ejemplo 10: Proceso FIFO (First In, First Out) con Semáforos y Swing","\u002Fejemplos\u002Fejemplo-10","7.ejemplos\u002F10.ejemplo-10",{"title":258,"icon":25,"path":259,"stem":260,"children":261,"page":104},"Actividades","\u002Factividades","8.actividades",[262,266,270,274,278,282,286,290,294],{"title":263,"path":264,"stem":265,"icon":25},"Actividad 1: Introducción al diseño de interfaces","\u002Factividades\u002Fact-01","8.actividades\u002F01.act-01",{"title":267,"path":268,"stem":269,"icon":25},"Actividad 2: Diseño de wireframes y prototipos","\u002Factividades\u002Fact-02","8.actividades\u002F02.act-02",{"title":271,"path":272,"stem":273,"icon":25},"Actividad 3: Propuesta de Proyecto y Wireframe inicial","\u002Factividades\u002Fact-03","8.actividades\u002F03.act-03",{"title":275,"path":276,"stem":277,"icon":83},"Actividad 4: Temas y Componentes Personalizados en Swing","\u002Factividades\u002Fact-04","8.actividades\u002F04.act-04",{"title":279,"path":280,"stem":281,"icon":83},"Actividad 5: Explicando la Concurrencia a un Niño de 5 Años","\u002Factividades\u002Fact-05","8.actividades\u002F05.act-05",{"title":283,"path":284,"stem":285,"icon":83},"Actividad 6: Simulación de una cocina con múltiples chefs (hilos)","\u002Factividades\u002Fact-06","8.actividades\u002F06.act-06",{"title":287,"path":288,"stem":289,"icon":83},"Actividad 7: Sistema de retiro bancario","\u002Factividades\u002Fact-07","8.actividades\u002F07.act-07",{"title":291,"path":292,"stem":293,"icon":83},"Actividad 8: Simulación de Round Robin con hilos e Interfaz Gráfica","\u002Factividades\u002Fact-08","8.actividades\u002F08.act-08",{"title":295,"path":296,"stem":297,"icon":83},"Actividad 9: CRUD con Hibernate y Swing","\u002Factividades\u002Fact-09","8.actividades\u002F09.act-09",{"id":299,"title":121,"body":300,"description":2041,"extension":2042,"links":2043,"meta":2044,"navigation":2045,"path":122,"seo":2046,"stem":123,"__hash__":2047},"docs\u002F4.concurrencia\u002F04.thread-runnable.md",{"type":301,"value":302,"toc":2009},"minimark",[303,328,335,352,457,470,516,531,537,550,555,558,563,582,586,589,830,833,879,885,889,898,901,964,967,970,1211,1218,1259,1266,1271,1275,1295,1298,1352,1355,1358,1664,1674,1717,1722,1726,1729,1744,1747,1753,1775,1843,1853,1905,1921,1933,1937,1940,1979,1989,1993,2005],[304,305,306,307,311,312,315,316,319,320,323,324,327],"p",{},"En Java, existen dos formas principales de crear y gestionar hilos: utilizando la clase ",[308,309,310],"code",{},"Thread"," o implementando la interfaz ",[308,313,314],{},"Runnable",". Ambas opciones permiten ejecutar tareas de manera concurrente, pero cada una tiene sus propias ventajas y desventajas. A continuación, exploraremos cómo utilizar ambas herramientas para crear hilos en Java. Y en que consiste el ciclo de vida de un hilo, así como los métodos más comunes para gestionarlos, como ",[308,317,318],{},"sleep()",", ",[308,321,322],{},"join()",", e ",[308,325,326],{},"interrupt()",".",[329,330,332,333],"h2",{"id":331},"creación-de-hilos-con-la-clase-thread","Creación de Hilos con la Clase ",[308,334,310],{},[304,336,337,338,340,341,343,344,347,348,351],{},"Para crear un hilo utilizando la clase ",[308,339,310],{},", debes extender la clase ",[308,342,310],{}," y sobrescribir el método ",[308,345,346],{},"run()",", que contiene el código que se ejecutará en el hilo. Luego, puedes crear una instancia de tu clase y llamar al método ",[308,349,350],{},"start()"," para iniciar el hilo.",[353,354,359],"pre",{"className":355,"code":356,"language":357,"meta":358,"style":358},"language-java shiki shiki-themes github-dark","public class MyThread extends Thread {\n    @Override\n    public void run() {\n        System.out.println(\"Hilo ejecutándose: \" + Thread.currentThread().getName());\n    }\n}\n","java","",[308,360,361,387,396,411,445,451],{"__ignoreMap":358},[362,363,366,370,373,377,380,383],"span",{"class":364,"line":365},"line",1,[362,367,369],{"class":368},"snl16","public",[362,371,372],{"class":368}," class",[362,374,376],{"class":375},"svObZ"," MyThread",[362,378,379],{"class":368}," extends",[362,381,382],{"class":375}," Thread",[362,384,386],{"class":385},"s95oV"," {\n",[362,388,390,393],{"class":364,"line":389},2,[362,391,392],{"class":385},"    @",[362,394,395],{"class":368},"Override\n",[362,397,399,402,405,408],{"class":364,"line":398},3,[362,400,401],{"class":368},"    public",[362,403,404],{"class":368}," void",[362,406,407],{"class":375}," run",[362,409,410],{"class":385},"() {\n",[362,412,414,417,420,423,427,430,433,436,439,442],{"class":364,"line":413},4,[362,415,416],{"class":385},"        System.out.",[362,418,419],{"class":375},"println",[362,421,422],{"class":385},"(",[362,424,426],{"class":425},"sU2Wk","\"Hilo ejecutándose: \"",[362,428,429],{"class":368}," +",[362,431,432],{"class":385}," Thread.",[362,434,435],{"class":375},"currentThread",[362,437,438],{"class":385},"().",[362,440,441],{"class":375},"getName",[362,443,444],{"class":385},"());\n",[362,446,448],{"class":364,"line":447},5,[362,449,450],{"class":385},"    }\n",[362,452,454],{"class":364,"line":453},6,[362,455,456],{"class":385},"}\n",[304,458,459,460,463,464,466,467,469],{},"En este ejemplo, hemos creado una clase ",[308,461,462],{},"MyThread"," que extiende ",[308,465,310],{}," y sobrescribe el método ",[308,468,346],{},". Para iniciar el hilo, puedes hacer lo siguiente:",[353,471,473],{"className":355,"code":472,"language":357,"meta":358,"style":358},"void main(){\n    MyThread thread1 = new MyThread();\n    thread1.start();\n}\n",[308,474,475,486,502,512],{"__ignoreMap":358},[362,476,477,480,483],{"class":364,"line":365},[362,478,479],{"class":368},"void",[362,481,482],{"class":375}," main",[362,484,485],{"class":385},"(){\n",[362,487,488,491,494,497,499],{"class":364,"line":389},[362,489,490],{"class":385},"    MyThread thread1 ",[362,492,493],{"class":368},"=",[362,495,496],{"class":368}," new",[362,498,376],{"class":375},[362,500,501],{"class":385},"();\n",[362,503,504,507,510],{"class":364,"line":398},[362,505,506],{"class":385},"    thread1.",[362,508,509],{"class":375},"start",[362,511,501],{"class":385},[362,513,514],{"class":364,"line":413},[362,515,456],{"class":385},[304,517,518,519,521,522,524,525,527,528,530],{},"En este caso, hemos creado una instancia de ",[308,520,462],{}," y llamado al método ",[308,523,350],{},", lo que iniciará el hilo y ejecutará el código dentro del método ",[308,526,346],{},". Es importante destacar que no debes llamar al método ",[308,529,346],{}," directamente, ya que esto ejecutará el código en el hilo principal en lugar de crear un nuevo hilo.",[304,532,533,534,536],{},"Este enfoque es sencillo y directo, pero tiene la limitación de que no puedes extender otra clase si ya estás extendiendo ",[308,535,310],{},", lo que puede ser un problema si necesitas heredar de otra clase.",[304,538,539,540,542,543,319,545,319,547,549],{},"Así mismo, la clase ",[308,541,310],{}," proporciona métodos adicionales para gestionar el hilo, como ",[308,544,322],{},[308,546,318],{},[308,548,326],{},", entre otros, que te permiten controlar el comportamiento del hilo de manera más precisa.",[551,552,554],"h3",{"id":553},"sleep","Sleep",[304,556,557],{},"El método sleep() es un método estático de la clase Thread que provoca que el hilo actualmente en ejecución (el que llama a sleep) suspenda temporalmente su actividad durante el período de tiempo especificado, expresado en milisegundos. El hilo no pierde la propiedad de ningún monitor que haya adquirido.",[559,560,562],"h4",{"id":561},"características-principales","Características Principales",[564,565,566,570,573,576,579],"ul",{},[567,568,569],"li",{},"Naturaleza estática: Siempre actúa sobre el hilo que lo ejecuta. Es común el error de pensar que t.sleep() hace dormir al hilo t, pero no es así; hace dormir al hilo actual.",[567,571,572],{},"No libera monitores (Locks): Si el hilo que se pone a dormir tiene uno o varios bloqueos, los retiene durante todo el período de sueño. Esto puede causar problemas de rendimiento o bloqueos si no se diseña con cuidado.",[567,574,575],{},"Lanza InterruptedException: Es un método \"interrumpible\". Si mientras el hilo duerme, otro hilo llama a su método interrupt(), este despertará inmediatamente y lanzará una excepción InterruptedException.",[567,577,578],{},"Estado del Hilo: Durante su ejecución, el hilo se encuentra en el estado TIMED_WAITING (espera con tiempo definido).",[567,580,581],{},"Precisión: La precisión del tiempo de espera depende del sistema operativo y del planificador de hilos del hardware subyacente.",[559,583,585],{"id":584},"ejemplo-de-uso","Ejemplo de Uso",[304,587,588],{},"Un caso de uso común es simular una tarea que lleva tiempo, como una operación de I\u002FO o un cálculo complejo, o para crear una pausa en la ejecución.",[353,590,592],{"className":355,"code":591,"language":357,"meta":358,"style":358},"public class EjemploSleep {\n    public static void main(String[] args) {\n        System.out.println(\"Hilo main: Inicio.\");\n\n        Thread tarea = new Thread(() -> {\n            System.out.println(\"Hilo secundario: Empezando a trabajar...\");\n            try {\n                \u002F\u002F Simula una tarea que dura 2 segundos\n                System.out.println(\"Hilo secundario: Me pondré a dormir por 2 segundos.\");\n                Thread.sleep(2000); \u002F\u002F El hilo secundario se duerme por 2000 ms\n                System.out.println(\"Hilo secundario: ¡Desperté! Tarea completada.\");\n            } catch (InterruptedException e) {\n                System.out.println(\"Hilo secundario: Alguien me interrumpió mientras dormía.\");\n            }\n        });\n\n        tarea.start();\n        System.out.println(\"Hilo main: El hilo secundario ha sido lanzado. Fin del main.\");\n    }\n}\n",[308,593,594,605,631,645,651,670,684,692,699,714,734,748,765,779,785,791,796,806,820,825],{"__ignoreMap":358},[362,595,596,598,600,603],{"class":364,"line":365},[362,597,369],{"class":368},[362,599,372],{"class":368},[362,601,602],{"class":375}," EjemploSleep",[362,604,386],{"class":385},[362,606,607,609,612,614,616,618,621,624,628],{"class":364,"line":389},[362,608,401],{"class":368},[362,610,611],{"class":368}," static",[362,613,404],{"class":368},[362,615,482],{"class":375},[362,617,422],{"class":385},[362,619,620],{"class":368},"String",[362,622,623],{"class":385},"[] ",[362,625,627],{"class":626},"s9osk","args",[362,629,630],{"class":385},") {\n",[362,632,633,635,637,639,642],{"class":364,"line":398},[362,634,416],{"class":385},[362,636,419],{"class":375},[362,638,422],{"class":385},[362,640,641],{"class":425},"\"Hilo main: Inicio.\"",[362,643,644],{"class":385},");\n",[362,646,647],{"class":364,"line":413},[362,648,650],{"emptyLinePlaceholder":649},true,"\n",[362,652,653,656,658,660,662,665,668],{"class":364,"line":447},[362,654,655],{"class":385},"        Thread tarea ",[362,657,493],{"class":368},[362,659,496],{"class":368},[362,661,382],{"class":375},[362,663,664],{"class":385},"(() ",[362,666,667],{"class":368},"->",[362,669,386],{"class":385},[362,671,672,675,677,679,682],{"class":364,"line":453},[362,673,674],{"class":385},"            System.out.",[362,676,419],{"class":375},[362,678,422],{"class":385},[362,680,681],{"class":425},"\"Hilo secundario: Empezando a trabajar...\"",[362,683,644],{"class":385},[362,685,687,690],{"class":364,"line":686},7,[362,688,689],{"class":368},"            try",[362,691,386],{"class":385},[362,693,695],{"class":364,"line":694},8,[362,696,698],{"class":697},"sAwPA","                \u002F\u002F Simula una tarea que dura 2 segundos\n",[362,700,702,705,707,709,712],{"class":364,"line":701},9,[362,703,704],{"class":385},"                System.out.",[362,706,419],{"class":375},[362,708,422],{"class":385},[362,710,711],{"class":425},"\"Hilo secundario: Me pondré a dormir por 2 segundos.\"",[362,713,644],{"class":385},[362,715,717,720,722,724,728,731],{"class":364,"line":716},10,[362,718,719],{"class":385},"                Thread.",[362,721,553],{"class":375},[362,723,422],{"class":385},[362,725,727],{"class":726},"sDLfK","2000",[362,729,730],{"class":385},"); ",[362,732,733],{"class":697},"\u002F\u002F El hilo secundario se duerme por 2000 ms\n",[362,735,737,739,741,743,746],{"class":364,"line":736},11,[362,738,704],{"class":385},[362,740,419],{"class":375},[362,742,422],{"class":385},[362,744,745],{"class":425},"\"Hilo secundario: ¡Desperté! Tarea completada.\"",[362,747,644],{"class":385},[362,749,751,754,757,760,763],{"class":364,"line":750},12,[362,752,753],{"class":385},"            } ",[362,755,756],{"class":368},"catch",[362,758,759],{"class":385}," (InterruptedException ",[362,761,762],{"class":626},"e",[362,764,630],{"class":385},[362,766,768,770,772,774,777],{"class":364,"line":767},13,[362,769,704],{"class":385},[362,771,419],{"class":375},[362,773,422],{"class":385},[362,775,776],{"class":425},"\"Hilo secundario: Alguien me interrumpió mientras dormía.\"",[362,778,644],{"class":385},[362,780,782],{"class":364,"line":781},14,[362,783,784],{"class":385},"            }\n",[362,786,788],{"class":364,"line":787},15,[362,789,790],{"class":385},"        });\n",[362,792,794],{"class":364,"line":793},16,[362,795,650],{"emptyLinePlaceholder":649},[362,797,799,802,804],{"class":364,"line":798},17,[362,800,801],{"class":385},"        tarea.",[362,803,509],{"class":375},[362,805,501],{"class":385},[362,807,809,811,813,815,818],{"class":364,"line":808},18,[362,810,416],{"class":385},[362,812,419],{"class":375},[362,814,422],{"class":385},[362,816,817],{"class":425},"\"Hilo main: El hilo secundario ha sido lanzado. Fin del main.\"",[362,819,644],{"class":385},[362,821,823],{"class":364,"line":822},19,[362,824,450],{"class":385},[362,826,828],{"class":364,"line":827},20,[362,829,456],{"class":385},[304,831,832],{},"Explicación paso a paso:",[834,835,837,841,844,848,851,855,858,862,865,869,872,876],"steps",{"level":836},"2",[329,838,840],{"id":839},"inicio-del-programa","Inicio del Programa",[304,842,843],{},"El hilo main comienza y crea un nuevo hilo (tarea).",[329,845,847],{"id":846},"creación-del-hilo-secundario","Creación del Hilo Secundario",[304,849,850],{},"main inicia la ejecución del hilo tarea con tarea.start().",[329,852,854],{"id":853},"continuación-del-hilo-main","Continuación del Hilo Main",[304,856,857],{},"El hilo main imprime su mensaje final y termina (aunque la JVM no termina hasta que todos los hilos no-daemon hayan acabado).",[329,859,861],{"id":860},"ejecución-del-hilo-secundario","Ejecución del Hilo Secundario",[304,863,864],{},"El hilo tarea comienza su ejecución. Imprime que empieza a trabajar.",[329,866,868],{"id":867},"estado-de-sleep","Estado de Sleep",[304,870,871],{},"Llega a Thread.sleep(2000). En este punto, el hilo tarea se bloquea a sí mismo y pasa al estado TIMED_WAITING. Durante estos 2 segundos, no consume CPU.",[329,873,875],{"id":874},"fin-del-sleep","Fin del Sleep",[304,877,878],{},"Tras los 2 segundos, el planificador de hilos de Java lo marca como \"ejecutable\" (runnable). Cuando la CPU esté disponible para él, el hilo tarea se despierta y continúa con la siguiente instrucción, imprimiendo que ha despertado.",[304,880,881,882,884],{},"En resumen, el método ",[308,883,318],{}," es una herramienta útil para controlar la ejecución de los hilos, permitiendo introducir pausas o simular tareas que llevan tiempo. Sin embargo, es importante usarlo con cuidado para evitar problemas de rendimiento o bloqueos en la aplicación.",[551,886,888],{"id":887},"join","Join",[304,890,891,892,894,895,897],{},"El método ",[308,893,322],{}," es un método de instancia de la clase Thread. Permite que un hilo espere a que otro hilo complete su ejecución antes de continuar. Si un hilo A llama a threadB.",[308,896,322],{},", el hilo A se suspenderá hasta que el hilo B termine.",[559,899,562],{"id":900},"características-principales-1",[564,902,903,912,928,943,951],{},[567,904,905,906,908,909,911],{},"Espera por finalización: Su propósito principal es la coordinación, asegurando que un hilo no prosiga hasta que otro haya muerto. Es decir, el hilo que llama a ",[308,907,322],{}," se bloquea hasta que el hilo sobre el que se llama ",[308,910,322],{}," termine su ejecución.",[567,913,914,915],{},"Versiones sobrecargadas: Existen tres versiones:\n",[564,916,917,922,925],{},[567,918,919,921],{},[308,920,322],{},": Espera indefinidamente hasta que el hilo muera.",[567,923,924],{},"join(long millis): Espera un máximo de millis milisegundos a que el hilo muera. Si pasa el tiempo, el hilo actual\ncontinúa.",[567,926,927],{},"join(long millis, int nanos): Espera con una precisión de nanosegundos.",[567,929,930,931,934,935,937,938,940,941,327],{},"Lanza ",[308,932,933],{},"InterruptedException",": Si mientras el hilo A espera en un ",[308,936,322],{},", otro hilo C llama a ",[308,939,326],{}," sobre el hilo A, este despertará y lanzará ",[308,942,933],{},[567,944,945,946,948,949,327],{},"Mecanismo interno: Internamente, ",[308,947,322],{}," utiliza wait(). Cuando un hilo termina, su objeto Thread llama a notifyAll() para despertar a todos los hilos que estén esperando en su ",[308,950,322],{},[567,952,953,954,956,957,959,960,963],{},"Estado del Hilo: El hilo que llama a ",[308,955,322],{}," pasa al estado WAITING (si es ",[308,958,322],{}," sin tiempo) o ",[308,961,962],{},"TIMED_WAITING"," (si es con tiempo).",[559,965,585],{"id":966},"ejemplo-de-uso-1",[304,968,969],{},"Ideal para descomponer un problema grande en subtareas que se ejecutan en paralelo y luego combinar sus resultados.",[353,971,973],{"className":355,"code":972,"language":357,"meta":358,"style":358},"public class EjemploJoin {\n    public static void main(String[] args) {\n        Thread calculoComplejo = new Thread(() -> {\n            try {\n                System.out.println(\"Hilo cálculo: Realizando tarea pesada...\");\n                Thread.sleep(3000); \u002F\u002F Simula un cálculo de 3 segundos\n                System.out.println(\"Hilo cálculo: Tarea pesada terminada.\");\n            } catch (InterruptedException e) {\n                e.printStackTrace();\n            }\n        });\n\n        calculoComplejo.start();\n\n        System.out.println(\"Hilo main: Esperando a que el hilo de cálculo termine...\");\n        try {\n            calculoComplejo.join(); \u002F\u002F main se detiene AQUÍ hasta que calculoComplejo muera\n        } catch (InterruptedException e) {\n            System.out.println(\"Hilo main: Me interrumpieron mientras esperaba.\");\n        }\n\n        System.out.println(\"Hilo main: El hilo de cálculo terminó. Ahora puedo procesar sus resultados y finalizar.\");\n    }\n}\n",[308,974,975,986,1006,1023,1029,1042,1058,1071,1083,1093,1097,1101,1105,1114,1118,1131,1138,1151,1164,1177,1182,1187,1201,1206],{"__ignoreMap":358},[362,976,977,979,981,984],{"class":364,"line":365},[362,978,369],{"class":368},[362,980,372],{"class":368},[362,982,983],{"class":375}," EjemploJoin",[362,985,386],{"class":385},[362,987,988,990,992,994,996,998,1000,1002,1004],{"class":364,"line":389},[362,989,401],{"class":368},[362,991,611],{"class":368},[362,993,404],{"class":368},[362,995,482],{"class":375},[362,997,422],{"class":385},[362,999,620],{"class":368},[362,1001,623],{"class":385},[362,1003,627],{"class":626},[362,1005,630],{"class":385},[362,1007,1008,1011,1013,1015,1017,1019,1021],{"class":364,"line":398},[362,1009,1010],{"class":385},"        Thread calculoComplejo ",[362,1012,493],{"class":368},[362,1014,496],{"class":368},[362,1016,382],{"class":375},[362,1018,664],{"class":385},[362,1020,667],{"class":368},[362,1022,386],{"class":385},[362,1024,1025,1027],{"class":364,"line":413},[362,1026,689],{"class":368},[362,1028,386],{"class":385},[362,1030,1031,1033,1035,1037,1040],{"class":364,"line":447},[362,1032,704],{"class":385},[362,1034,419],{"class":375},[362,1036,422],{"class":385},[362,1038,1039],{"class":425},"\"Hilo cálculo: Realizando tarea pesada...\"",[362,1041,644],{"class":385},[362,1043,1044,1046,1048,1050,1053,1055],{"class":364,"line":453},[362,1045,719],{"class":385},[362,1047,553],{"class":375},[362,1049,422],{"class":385},[362,1051,1052],{"class":726},"3000",[362,1054,730],{"class":385},[362,1056,1057],{"class":697},"\u002F\u002F Simula un cálculo de 3 segundos\n",[362,1059,1060,1062,1064,1066,1069],{"class":364,"line":686},[362,1061,704],{"class":385},[362,1063,419],{"class":375},[362,1065,422],{"class":385},[362,1067,1068],{"class":425},"\"Hilo cálculo: Tarea pesada terminada.\"",[362,1070,644],{"class":385},[362,1072,1073,1075,1077,1079,1081],{"class":364,"line":694},[362,1074,753],{"class":385},[362,1076,756],{"class":368},[362,1078,759],{"class":385},[362,1080,762],{"class":626},[362,1082,630],{"class":385},[362,1084,1085,1088,1091],{"class":364,"line":701},[362,1086,1087],{"class":385},"                e.",[362,1089,1090],{"class":375},"printStackTrace",[362,1092,501],{"class":385},[362,1094,1095],{"class":364,"line":716},[362,1096,784],{"class":385},[362,1098,1099],{"class":364,"line":736},[362,1100,790],{"class":385},[362,1102,1103],{"class":364,"line":750},[362,1104,650],{"emptyLinePlaceholder":649},[362,1106,1107,1110,1112],{"class":364,"line":767},[362,1108,1109],{"class":385},"        calculoComplejo.",[362,1111,509],{"class":375},[362,1113,501],{"class":385},[362,1115,1116],{"class":364,"line":781},[362,1117,650],{"emptyLinePlaceholder":649},[362,1119,1120,1122,1124,1126,1129],{"class":364,"line":787},[362,1121,416],{"class":385},[362,1123,419],{"class":375},[362,1125,422],{"class":385},[362,1127,1128],{"class":425},"\"Hilo main: Esperando a que el hilo de cálculo termine...\"",[362,1130,644],{"class":385},[362,1132,1133,1136],{"class":364,"line":793},[362,1134,1135],{"class":368},"        try",[362,1137,386],{"class":385},[362,1139,1140,1143,1145,1148],{"class":364,"line":798},[362,1141,1142],{"class":385},"            calculoComplejo.",[362,1144,887],{"class":375},[362,1146,1147],{"class":385},"(); ",[362,1149,1150],{"class":697},"\u002F\u002F main se detiene AQUÍ hasta que calculoComplejo muera\n",[362,1152,1153,1156,1158,1160,1162],{"class":364,"line":808},[362,1154,1155],{"class":385},"        } ",[362,1157,756],{"class":368},[362,1159,759],{"class":385},[362,1161,762],{"class":626},[362,1163,630],{"class":385},[362,1165,1166,1168,1170,1172,1175],{"class":364,"line":822},[362,1167,674],{"class":385},[362,1169,419],{"class":375},[362,1171,422],{"class":385},[362,1173,1174],{"class":425},"\"Hilo main: Me interrumpieron mientras esperaba.\"",[362,1176,644],{"class":385},[362,1178,1179],{"class":364,"line":827},[362,1180,1181],{"class":385},"        }\n",[362,1183,1185],{"class":364,"line":1184},21,[362,1186,650],{"emptyLinePlaceholder":649},[362,1188,1190,1192,1194,1196,1199],{"class":364,"line":1189},22,[362,1191,416],{"class":385},[362,1193,419],{"class":375},[362,1195,422],{"class":385},[362,1197,1198],{"class":425},"\"Hilo main: El hilo de cálculo terminó. Ahora puedo procesar sus resultados y finalizar.\"",[362,1200,644],{"class":385},[362,1202,1204],{"class":364,"line":1203},23,[362,1205,450],{"class":385},[362,1207,1209],{"class":364,"line":1208},24,[362,1210,456],{"class":385},[304,1212,1213,1214,1217],{},"En este ejemplo, el hilo main inicia un hilo llamado calculoComplejo que simula una tarea pesada. Luego, el hilo main llama a ",[308,1215,1216],{},"calculoComplejo.join()",", lo que hace que el hilo main se bloquee hasta que el hilo calculoComplejo termine su ejecución. Una vez que calculoComplejo ha terminado, el hilo main continúa y puede procesar los resultados de la tarea pesada antes de finalizar.",[834,1219,1220,1223,1226,1230,1236,1240,1246,1250,1253,1256],{"level":836},[329,1221,840],{"id":1222},"inicio-del-programa-1",[304,1224,1225],{},"El hilo main comienza y crea un nuevo hilo (calculoComplejo).",[329,1227,1229],{"id":1228},"ejecución-del-hilo-de-cálculo","Ejecución del Hilo de Cálculo",[304,1231,1232,1233,327],{},"El hilo calculoComplejo inicia su ejecución y simula una tarea pesada con ",[308,1234,1235],{},"Thread.sleep(3000)",[329,1237,1239],{"id":1238},"espera-del-hilo-main","Espera del Hilo Main",[304,1241,1242,1243,1245],{},"Mientras calculoComplejo está \"durmiendo\", el hilo main llama a ",[308,1244,1216],{},", lo que hace que el hilo main se bloquee y espere a que calculoComplejo termine.",[329,1247,1249],{"id":1248},"fin-del-hilo-de-cálculo","Fin del Hilo de Cálculo",[304,1251,1252],{},"Después de 3 segundos, calculoComplejo termina su tarea y muere. Esto hace que el hilo main se despierte y continúe su ejecución.",[329,1254,854],{"id":1255},"continuación-del-hilo-main-1",[304,1257,1258],{},"El hilo main imprime que el hilo de cálculo terminó y puede procesar los resultados antes de finalizar.",[1260,1261,1262],"warning",{},[1263,1264,1265],"strong",{},"Nota crucial: El método join() debe llamarse después de start(). Si se llama antes, el hilo objetivo aún no está vivo (isAlive() es false), y join() retornará inmediatamente sin esperar, lo que puede llevar a errores lógicos en el programa.",[304,1267,881,1268,1270],{},[308,1269,322],{}," es una herramienta esencial para coordinar la ejecución de hilos en Java, permitiendo que un hilo espere a que otro termine antes de continuar. Es especialmente útil para descomponer tareas complejas en subtareas concurrentes y luego combinar sus resultados de manera ordenada. Sin embargo, es importante usarlo correctamente para evitar bloqueos innecesarios o errores lógicos en la aplicación.",[551,1272,1274],{"id":1273},"interrupt","Interrupt",[304,1276,891,1277,1279,1280,1282,1283,319,1285,1288,1289,1291,1292,1294],{},[308,1278,326],{}," es un método de instancia de la clase Thread que se utiliza para interrumpir un hilo que está en ejecución. Cuando se llama a ",[308,1281,326],{}," sobre un hilo, se establece un indicador de interrupción en ese hilo. Si el hilo está bloqueado en una operación que puede ser interrumpida (como ",[308,1284,318],{},[308,1286,1287],{},"wait()",", o ",[308,1290,322],{},"), se lanzará una excepción ",[308,1293,933],{}," y el hilo podrá manejar esta interrupción de manera adecuada.",[559,1296,562],{"id":1297},"características-principales-2",[564,1299,1300,1306,1327,1338,1344,1347],{},[567,1301,1302,1303,1305],{},"Indicador de Interrupción: Llamar a ",[308,1304,326],{}," no detiene inmediatamente el hilo, sino que establece un indicador de interrupción. El hilo debe verificar este indicador para responder a la interrupción.",[567,1307,1308,1309,319,1311,1288,1313,1315,1316,1318,1319],{},"Interrupción de Operaciones Bloqueantes: Si el hilo está bloqueado en una operación que puede ser interrumpida, como ",[308,1310,318],{},[308,1312,1287],{},[308,1314,322],{},", se lanzará una excepción ",[308,1317,933],{},", lo que permite al hilo manejar la interrupción de manera adecuada.\n",[564,1320,1321],{},[567,1322,1323,1324,1326],{},"No Detiene el Hilo: Si el hilo no está bloqueado en una operación interrumpible, el método ",[308,1325,326],{}," simplemente establece el indicador de interrupción, y el hilo debe verificar este indicador para decidir cómo responder a la interrupción.",[567,1328,1329,1330,1333,1334,1337],{},"Verificación del Indicador: El hilo puede verificar el indicador de interrupción utilizando el método ",[308,1331,1332],{},"isInterrupted()"," o el método estático ",[308,1335,1336],{},"Thread.interrupted()",", que también limpia el indicador de interrupción.",[567,1339,1340,1341,1343],{},"Uso Común: El método ",[308,1342,326],{}," se utiliza comúnmente para solicitar que un hilo se detenga de manera cooperativa, especialmente en situaciones donde el hilo está realizando una tarea que puede ser interrumpida, como esperar por recursos, dormir, o realizar operaciones de I\u002FO.",[567,1345,1346],{},"Manejo de Interrupciones: Es importante que los hilos manejen las interrupciones de manera adecuada, ya sea limpiando recursos, cerrando conexiones, o simplemente terminando su ejecución de manera ordenada.",[567,1348,1349,1351],{},[308,1350,933],{},": Los métodos que lanzan esta excepción lo hacen para notificar que han sido interrumpidos mientras estaban en un estado de bloqueo. Es una señal para que el hilo finalice su tarea lo antes posible.",[559,1353,585],{"id":1354},"ejemplo-de-uso-2",[304,1356,1357],{},"El ejemplo clásico es un hilo que ejecuta un trabajo largo pero que debe ser capaz de cancelarse bajo demanda.",[353,1359,1361],{"className":355,"code":1360,"language":357,"meta":358,"style":358},"public class EjemploInterrupt {\n    public static void main(String[] args) {\n        Thread trabajador = new Thread(() -> {\n            while (!Thread.currentThread().isInterrupted()) { \u002F\u002F 1. Comprueba la bandera\n                System.out.println(\"Hilo trabajador: trabajando...\");\n                try {\n                    Thread.sleep(500); \u002F\u002F 2. Simula trabajo que puede ser bloqueante\n                } catch (InterruptedException e) {\n                    \u002F\u002F 4. Si nos interrumpen mientras dormimos, la bandera se limpia\n                    System.out.println(\"Hilo trabajador: ¡Me interrumpieron durante el sueño! Saliendo.\");\n                    Thread.currentThread().interrupt(); \u002F\u002F Es buena práctica restaurar el estado de interrupción\n                    break; \u002F\u002F Sale del bucle\n                }\n            }\n            System.out.println(\"Hilo trabajador: Trabajo finalizado.\");\n        });\n\n        trabajador.start();\n\n        try {\n            Thread.sleep(2000); \u002F\u002F El main duerme 2 segundos\n        } catch (InterruptedException e) {\n            e.printStackTrace();\n        }\n\n        System.out.println(\"Hilo main: Es hora de parar al trabajador.\");\n        trabajador.interrupt(); \u002F\u002F 3. Se envía la señal de interrupción\n    }\n}\n",[308,1362,1363,1374,1394,1411,1438,1451,1458,1475,1488,1493,1507,1522,1533,1538,1542,1555,1559,1563,1572,1576,1582,1598,1610,1619,1623,1628,1642,1654,1659],{"__ignoreMap":358},[362,1364,1365,1367,1369,1372],{"class":364,"line":365},[362,1366,369],{"class":368},[362,1368,372],{"class":368},[362,1370,1371],{"class":375}," EjemploInterrupt",[362,1373,386],{"class":385},[362,1375,1376,1378,1380,1382,1384,1386,1388,1390,1392],{"class":364,"line":389},[362,1377,401],{"class":368},[362,1379,611],{"class":368},[362,1381,404],{"class":368},[362,1383,482],{"class":375},[362,1385,422],{"class":385},[362,1387,620],{"class":368},[362,1389,623],{"class":385},[362,1391,627],{"class":626},[362,1393,630],{"class":385},[362,1395,1396,1399,1401,1403,1405,1407,1409],{"class":364,"line":398},[362,1397,1398],{"class":385},"        Thread trabajador ",[362,1400,493],{"class":368},[362,1402,496],{"class":368},[362,1404,382],{"class":375},[362,1406,664],{"class":385},[362,1408,667],{"class":368},[362,1410,386],{"class":385},[362,1412,1413,1416,1419,1422,1425,1427,1429,1432,1435],{"class":364,"line":413},[362,1414,1415],{"class":368},"            while",[362,1417,1418],{"class":385}," (",[362,1420,1421],{"class":368},"!",[362,1423,1424],{"class":385},"Thread.",[362,1426,435],{"class":375},[362,1428,438],{"class":385},[362,1430,1431],{"class":375},"isInterrupted",[362,1433,1434],{"class":385},"()) { ",[362,1436,1437],{"class":697},"\u002F\u002F 1. Comprueba la bandera\n",[362,1439,1440,1442,1444,1446,1449],{"class":364,"line":447},[362,1441,704],{"class":385},[362,1443,419],{"class":375},[362,1445,422],{"class":385},[362,1447,1448],{"class":425},"\"Hilo trabajador: trabajando...\"",[362,1450,644],{"class":385},[362,1452,1453,1456],{"class":364,"line":453},[362,1454,1455],{"class":368},"                try",[362,1457,386],{"class":385},[362,1459,1460,1463,1465,1467,1470,1472],{"class":364,"line":686},[362,1461,1462],{"class":385},"                    Thread.",[362,1464,553],{"class":375},[362,1466,422],{"class":385},[362,1468,1469],{"class":726},"500",[362,1471,730],{"class":385},[362,1473,1474],{"class":697},"\u002F\u002F 2. Simula trabajo que puede ser bloqueante\n",[362,1476,1477,1480,1482,1484,1486],{"class":364,"line":694},[362,1478,1479],{"class":385},"                } ",[362,1481,756],{"class":368},[362,1483,759],{"class":385},[362,1485,762],{"class":626},[362,1487,630],{"class":385},[362,1489,1490],{"class":364,"line":701},[362,1491,1492],{"class":697},"                    \u002F\u002F 4. Si nos interrumpen mientras dormimos, la bandera se limpia\n",[362,1494,1495,1498,1500,1502,1505],{"class":364,"line":716},[362,1496,1497],{"class":385},"                    System.out.",[362,1499,419],{"class":375},[362,1501,422],{"class":385},[362,1503,1504],{"class":425},"\"Hilo trabajador: ¡Me interrumpieron durante el sueño! Saliendo.\"",[362,1506,644],{"class":385},[362,1508,1509,1511,1513,1515,1517,1519],{"class":364,"line":736},[362,1510,1462],{"class":385},[362,1512,435],{"class":375},[362,1514,438],{"class":385},[362,1516,1273],{"class":375},[362,1518,1147],{"class":385},[362,1520,1521],{"class":697},"\u002F\u002F Es buena práctica restaurar el estado de interrupción\n",[362,1523,1524,1527,1530],{"class":364,"line":750},[362,1525,1526],{"class":368},"                    break",[362,1528,1529],{"class":385},"; ",[362,1531,1532],{"class":697},"\u002F\u002F Sale del bucle\n",[362,1534,1535],{"class":364,"line":767},[362,1536,1537],{"class":385},"                }\n",[362,1539,1540],{"class":364,"line":781},[362,1541,784],{"class":385},[362,1543,1544,1546,1548,1550,1553],{"class":364,"line":787},[362,1545,674],{"class":385},[362,1547,419],{"class":375},[362,1549,422],{"class":385},[362,1551,1552],{"class":425},"\"Hilo trabajador: Trabajo finalizado.\"",[362,1554,644],{"class":385},[362,1556,1557],{"class":364,"line":793},[362,1558,790],{"class":385},[362,1560,1561],{"class":364,"line":798},[362,1562,650],{"emptyLinePlaceholder":649},[362,1564,1565,1568,1570],{"class":364,"line":808},[362,1566,1567],{"class":385},"        trabajador.",[362,1569,509],{"class":375},[362,1571,501],{"class":385},[362,1573,1574],{"class":364,"line":822},[362,1575,650],{"emptyLinePlaceholder":649},[362,1577,1578,1580],{"class":364,"line":827},[362,1579,1135],{"class":368},[362,1581,386],{"class":385},[362,1583,1584,1587,1589,1591,1593,1595],{"class":364,"line":1184},[362,1585,1586],{"class":385},"            Thread.",[362,1588,553],{"class":375},[362,1590,422],{"class":385},[362,1592,727],{"class":726},[362,1594,730],{"class":385},[362,1596,1597],{"class":697},"\u002F\u002F El main duerme 2 segundos\n",[362,1599,1600,1602,1604,1606,1608],{"class":364,"line":1189},[362,1601,1155],{"class":385},[362,1603,756],{"class":368},[362,1605,759],{"class":385},[362,1607,762],{"class":626},[362,1609,630],{"class":385},[362,1611,1612,1615,1617],{"class":364,"line":1203},[362,1613,1614],{"class":385},"            e.",[362,1616,1090],{"class":375},[362,1618,501],{"class":385},[362,1620,1621],{"class":364,"line":1208},[362,1622,1181],{"class":385},[362,1624,1626],{"class":364,"line":1625},25,[362,1627,650],{"emptyLinePlaceholder":649},[362,1629,1631,1633,1635,1637,1640],{"class":364,"line":1630},26,[362,1632,416],{"class":385},[362,1634,419],{"class":375},[362,1636,422],{"class":385},[362,1638,1639],{"class":425},"\"Hilo main: Es hora de parar al trabajador.\"",[362,1641,644],{"class":385},[362,1643,1645,1647,1649,1651],{"class":364,"line":1644},27,[362,1646,1567],{"class":385},[362,1648,1273],{"class":375},[362,1650,1147],{"class":385},[362,1652,1653],{"class":697},"\u002F\u002F 3. Se envía la señal de interrupción\n",[362,1655,1657],{"class":364,"line":1656},28,[362,1658,450],{"class":385},[362,1660,1662],{"class":364,"line":1661},29,[362,1663,456],{"class":385},[304,1665,1666,1667,1670,1671,1673],{},"En este ejemplo, el hilo trabajador ejecuta un bucle que simula trabajo. El hilo main duerme durante 2 segundos y luego llama a ",[308,1668,1669],{},"trabajador.interrupt()",", lo que establece el indicador de interrupción en el hilo trabajador. Si el hilo trabajador está dormido en ese momento, se lanzará una excepción ",[308,1672,933],{},", que es manejada para salir del bucle y finalizar la ejecución del hilo de manera ordenada.",[834,1675,1676,1679,1682,1686,1692,1696,1702,1706,1711,1714],{"level":836},[329,1677,840],{"id":1678},"inicio-del-programa-2",[304,1680,1681],{},"El hilo main comienza y crea un nuevo hilo (trabajador).",[329,1683,1685],{"id":1684},"ejecución-del-hilo-trabajador","Ejecución del Hilo Trabajador",[304,1687,1688,1689,327],{},"El hilo trabajador inicia su ejecución y entra en un bucle donde simula trabajo con ",[308,1690,1691],{},"Thread.sleep(500)",[329,1693,1695],{"id":1694},"interrupción-del-hilo-trabajador","Interrupción del Hilo Trabajador",[304,1697,1698,1699,1701],{},"Después de 2 segundos, el hilo main llama a ",[308,1700,1669],{},", lo que establece el indicador de interrupción en el hilo trabajador.",[329,1703,1705],{"id":1704},"manejo-de-la-interrupción","Manejo de la Interrupción",[304,1707,1708,1709,1673],{},"Si el hilo trabajador está dormido en ese momento, se lanzará una excepción ",[308,1710,933],{},[329,1712,854],{"id":1713},"continuación-del-hilo-main-2",[304,1715,1716],{},"El hilo main imprime un mensaje indicando que es hora de parar al trabajador y luego finaliza su ejecución.",[304,1718,881,1719,1721],{},[308,1720,326],{}," es una herramienta esencial para gestionar la interrupción de hilos en Java, permitiendo que un hilo solicite a otro que se detenga de manera cooperativa. Es importante que los hilos manejen las interrupciones de manera adecuada para garantizar que los recursos se liberen correctamente y que la aplicación funcione de manera estable.",[551,1723,1725],{"id":1724},"relación-entre-join-sleep-e-interrupt","Relación entre Join, Sleep e Interrupt",[304,1727,1728],{},"La relación entre estos métodos es clave:",[564,1730,1731,1739],{},[567,1732,1733,1735,1736,1738],{},[308,1734,318],{}," y ",[308,1737,322],{}," son métodos que ponen al hilo en un estado de espera.",[567,1740,1741,1743],{},[308,1742,326],{}," es el método que se utiliza para sacar a un hilo de esos estados de espera de forma anticipada, lanzando una InterruptedException para que el hilo pueda manejar la señal de parada.",[304,1745,1746],{},"En conjunto, estos métodos permiten una gestión efectiva de la concurrencia en Java, permitiendo que los hilos se coordinen entre sí y respondan a señales de interrupción de manera adecuada. Es fundamental entender cómo funcionan estos métodos para diseñar aplicaciones concurrentes robustas y eficientes.",[329,1748,1750,1751],{"id":1749},"creación-de-hilos-con-la-interfaz-runnable","Creación de Hilos con la Interfaz ",[308,1752,314],{},[304,1754,1755,1756,1758,1759,1761,1762,1764,1765,343,1767,1769,1770,1772,1773,351],{},"Otra forma de crear un hilo en Java es implementando la interfaz ",[308,1757,314],{},". Esto es generalmente preferido, ya que permite una mayor flexibilidad al no requerir la extensión de la clase ",[308,1760,310],{},", lo que significa que tu clase puede extender otra clase si es necesario. Para crear un hilo utilizando ",[308,1763,314],{},", debes implementar la interfaz ",[308,1766,314],{},[308,1768,346],{},", que contiene el código que se ejecutará en el hilo. Luego, puedes crear una instancia de tu clase ",[308,1771,314],{}," y pasarla al constructor de ",[308,1774,310],{},[353,1776,1778],{"className":355,"code":1777,"language":357,"meta":358,"style":358},"public class MyRunnable implements Runnable {\n    @Override\n    public void run() {\n        System.out.println(\"Hilo ejecutándose: \" + Thread.currentThread().getName());\n    }\n}\n",[308,1779,1780,1797,1803,1813,1835,1839],{"__ignoreMap":358},[362,1781,1782,1784,1786,1789,1792,1795],{"class":364,"line":365},[362,1783,369],{"class":368},[362,1785,372],{"class":368},[362,1787,1788],{"class":375}," MyRunnable",[362,1790,1791],{"class":368}," implements",[362,1793,1794],{"class":375}," Runnable",[362,1796,386],{"class":385},[362,1798,1799,1801],{"class":364,"line":389},[362,1800,392],{"class":385},[362,1802,395],{"class":368},[362,1804,1805,1807,1809,1811],{"class":364,"line":398},[362,1806,401],{"class":368},[362,1808,404],{"class":368},[362,1810,407],{"class":375},[362,1812,410],{"class":385},[362,1814,1815,1817,1819,1821,1823,1825,1827,1829,1831,1833],{"class":364,"line":413},[362,1816,416],{"class":385},[362,1818,419],{"class":375},[362,1820,422],{"class":385},[362,1822,426],{"class":425},[362,1824,429],{"class":368},[362,1826,432],{"class":385},[362,1828,435],{"class":375},[362,1830,438],{"class":385},[362,1832,441],{"class":375},[362,1834,444],{"class":385},[362,1836,1837],{"class":364,"line":447},[362,1838,450],{"class":385},[362,1840,1841],{"class":364,"line":453},[362,1842,456],{"class":385},[304,1844,459,1845,1848,1849,466,1851,469],{},[308,1846,1847],{},"MyRunnable"," que implementa la interfaz ",[308,1850,314],{},[308,1852,346],{},[353,1854,1856],{"className":355,"code":1855,"language":357,"meta":358,"style":358},"void main(){\n    MyRunnable runnable = new MyRunnable();\n    Thread thread1 = new Thread(runnable);\n    thread1.start();\n}\n",[308,1857,1858,1866,1879,1893,1901],{"__ignoreMap":358},[362,1859,1860,1862,1864],{"class":364,"line":365},[362,1861,479],{"class":368},[362,1863,482],{"class":375},[362,1865,485],{"class":385},[362,1867,1868,1871,1873,1875,1877],{"class":364,"line":389},[362,1869,1870],{"class":385},"    MyRunnable runnable ",[362,1872,493],{"class":368},[362,1874,496],{"class":368},[362,1876,1788],{"class":375},[362,1878,501],{"class":385},[362,1880,1881,1884,1886,1888,1890],{"class":364,"line":398},[362,1882,1883],{"class":385},"    Thread thread1 ",[362,1885,493],{"class":368},[362,1887,496],{"class":368},[362,1889,382],{"class":375},[362,1891,1892],{"class":385},"(runnable);\n",[362,1894,1895,1897,1899],{"class":364,"line":413},[362,1896,506],{"class":385},[362,1898,509],{"class":375},[362,1900,501],{"class":385},[362,1902,1903],{"class":364,"line":447},[362,1904,456],{"class":385},[304,1906,518,1907,1909,1910,1912,1913,1915,1916,1918,1919,530],{},[308,1908,1847],{},", luego hemos creado un nuevo hilo pasando esa instancia al constructor de ",[308,1911,310],{},", y finalmente hemos llamado al método ",[308,1914,350],{}," para iniciar el hilo. Al igual que con la clase ",[308,1917,310],{},", no debes llamar al método ",[308,1920,346],{},[304,1922,1923,1924,1926,1927,1929,1930,1932],{},"Este enfoque es más flexible que extender ",[308,1925,310],{},", ya que permite que tu clase implemente otras interfaces o extienda otra clase si es necesario. Además, es una práctica común en Java utilizar ",[308,1928,314],{}," para definir la tarea que se ejecutará en un hilo, y luego usar ",[308,1931,310],{}," para gestionar la ejecución de esa tarea.",[329,1934,1936],{"id":1935},"ciclo-de-vida-de-un-hilo","Ciclo de Vida de un Hilo",[304,1938,1939],{},"Un hilo en Java pasa por varios estados a lo largo de su ciclo de vida. Estos estados son:",[1941,1942,1943,1949,1955,1961,1967,1973],"ol",{},[567,1944,1945,1948],{},[1263,1946,1947],{},"Nuevo (New)",": El hilo se ha creado, pero aún no ha comenzado a ejecutarse. En este estado, el hilo no es elegible para la ejecución.",[567,1950,1951,1954],{},[1263,1952,1953],{},"Ejecutable (Runnable)",": El hilo está listo para ejecutarse y espera a que el planificador de hilos lo seleccione para su ejecución. En este estado, el hilo puede ser seleccionado por el planificador para ejecutarse.",[567,1956,1957,1960],{},[1263,1958,1959],{},"En Ejecución (Running)",": El hilo está actualmente en ejecución. En este estado, el hilo está utilizando la CPU para ejecutar su código.",[567,1962,1963,1966],{},[1263,1964,1965],{},"Bloqueado (Blocked)",": El hilo está bloqueado esperando a que ocurra un evento específico, como la liberación de un recurso o la finalización de otro hilo.",[567,1968,1969,1972],{},[1263,1970,1971],{},"Terminado (Terminated)",": El hilo ha completado su ejecución o ha sido interrumpido. En este estado, el hilo ya no es elegible para la ejecución.",[567,1974,1975,1978],{},[1263,1976,1977],{},"Esperando (Waiting)",": El hilo está esperando indefinidamente a que otro hilo realice una acción específica, como notificarlo o interrumpirlo.",[304,1980,1981,1982,319,1984,323,1986,1988],{},"Para poder gestionar estos estados, Java proporciona varios métodos, como ",[308,1983,318],{},[308,1985,322],{},[308,1987,326],{},", que permiten controlar el comportamiento de los hilos y coordinar su ejecución de manera efectiva. Lo cual hemos visto en detalle en las secciones anteriores.",[329,1990,1992],{"id":1991},"conclusión","Conclusión",[304,1994,1995,1996,1998,1999,2001,2002,2004],{},"En resumen, tanto la clase ",[308,1997,310],{}," como la interfaz ",[308,2000,314],{}," son herramientas fundamentales para crear y gestionar hilos en Java. La elección entre ambos enfoques depende de las necesidades específicas de tu aplicación y de tu preferencia personal, pero en general, implementar ",[308,2003,314],{}," es considerado una mejor práctica debido a su mayor flexibilidad.",[2006,2007,2008],"style",{},"html pre.shiki code .snl16, html code.shiki .snl16{--shiki-default:#F97583}html pre.shiki code .svObZ, html code.shiki .svObZ{--shiki-default:#B392F0}html pre.shiki code .s95oV, html code.shiki .s95oV{--shiki-default:#E1E4E8}html pre.shiki code .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html pre.shiki code .s9osk, html code.shiki .s9osk{--shiki-default:#FFAB70}html pre.shiki code .sAwPA, html code.shiki .sAwPA{--shiki-default:#6A737D}html pre.shiki code .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}",{"title":358,"searchDepth":389,"depth":389,"links":2010},[2011,2015,2016,2017,2018,2019,2020,2023,2024,2025,2026,2027,2030,2031,2032,2033,2034,2037,2039,2040],{"id":331,"depth":389,"text":2012,"children":2013},"Creación de Hilos con la Clase Thread",[2014],{"id":553,"depth":398,"text":554},{"id":839,"depth":389,"text":840},{"id":846,"depth":389,"text":847},{"id":853,"depth":389,"text":854},{"id":860,"depth":389,"text":861},{"id":867,"depth":389,"text":868},{"id":874,"depth":389,"text":875,"children":2021},[2022],{"id":887,"depth":398,"text":888},{"id":1222,"depth":389,"text":840},{"id":1228,"depth":389,"text":1229},{"id":1238,"depth":389,"text":1239},{"id":1248,"depth":389,"text":1249},{"id":1255,"depth":389,"text":854,"children":2028},[2029],{"id":1273,"depth":398,"text":1274},{"id":1678,"depth":389,"text":840},{"id":1684,"depth":389,"text":1685},{"id":1694,"depth":389,"text":1695},{"id":1704,"depth":389,"text":1705},{"id":1713,"depth":389,"text":854,"children":2035},[2036],{"id":1724,"depth":398,"text":1725},{"id":1749,"depth":389,"text":2038},"Creación de Hilos con la Interfaz Runnable",{"id":1935,"depth":389,"text":1936},{"id":1991,"depth":389,"text":1992},"En esta sección, exploraremos cómo crear y gestionar hilos en Java utilizando las clases `Thread` y `Runnable`, y cómo estas herramientas permiten ejecutar tareas de manera concurrente para mejorar el rendimiento de las aplicaciones.","md",null,{"editButton":104},{"icon":83},{"title":121,"description":2041},"2naGGSxsBrB_Mj_B3LXoxkg7RF7DkM_brNd0HqGMA0A",[2049,2051],{"title":117,"path":118,"stem":119,"description":2050,"icon":83,"children":-1},"En esta sección, exploraremos los conceptos de programa de flujo único y de flujo múltiple, y cómo estos enfoques afectan la ejecución de tareas en una aplicación.",{"title":125,"path":126,"stem":127,"description":2052,"children":-1},"Diferencia entre paralelismo y concurrencia",1775101372475]