[{"data":1,"prerenderedAt":1018},["ShallowReactive",2],{"navigation_docs":3,"-concurrencia-condiciones-carrera":298,"-concurrencia-condiciones-carrera-surround":1013},[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":133,"body":300,"description":1006,"extension":1007,"links":1008,"meta":1009,"navigation":1010,"path":134,"seo":1011,"stem":135,"__hash__":1012},"docs\u002F4.concurrencia\u002F07.condiciones-carrera.md",{"type":301,"value":302,"toc":997},"minimark",[303,308,312,316,328,455,461,467,744,750,754,760,846,856,860,865,876,880,887,973,986,990,993],[304,305,307],"h2",{"id":306},"condiciones-de-carrera","Condiciones de carrera",[309,310,311],"p",{},"Una condición de carrera ocurre cuando dos o más hilos acceden a un recurso compartido sin la debida sincronización, lo que puede llevar a resultados impredecibles. Para ilustrar este concepto, vamos a emular una condición de carrera en Java utilizando un ejemplo práctico.",[304,313,315],{"id":314},"ejemplo-de-condición-de-carrera","Ejemplo de condición de carrera",[309,317,318,319,323,324,327],{},"Supongamos que tenemos una clase ",[320,321,322],"code",{},"Counter"," que tiene un método ",[320,325,326],{},"increment()"," para incrementar un contador compartido. Si varios hilos llaman a este método al mismo tiempo sin sincronización, podemos obtener resultados incorrectos debido a la condición de carrera.",[329,330,335],"pre",{"className":331,"code":332,"language":333,"meta":334,"style":334},"language-java shiki shiki-themes github-dark","public class Counter {\n    private int count = 0;\n\n    public void increment() {\n        count++;\n    }\n\n    public int getCount() {\n        return count;\n    }\n}\n","java","",[320,336,337,357,379,386,401,412,418,423,435,444,449],{"__ignoreMap":334},[338,339,342,346,349,353],"span",{"class":340,"line":341},"line",1,[338,343,345],{"class":344},"snl16","public",[338,347,348],{"class":344}," class",[338,350,352],{"class":351},"svObZ"," Counter",[338,354,356],{"class":355},"s95oV"," {\n",[338,358,360,363,366,369,372,376],{"class":340,"line":359},2,[338,361,362],{"class":344},"    private",[338,364,365],{"class":344}," int",[338,367,368],{"class":355}," count ",[338,370,371],{"class":344},"=",[338,373,375],{"class":374},"sDLfK"," 0",[338,377,378],{"class":355},";\n",[338,380,382],{"class":340,"line":381},3,[338,383,385],{"emptyLinePlaceholder":384},true,"\n",[338,387,389,392,395,398],{"class":340,"line":388},4,[338,390,391],{"class":344},"    public",[338,393,394],{"class":344}," void",[338,396,397],{"class":351}," increment",[338,399,400],{"class":355},"() {\n",[338,402,404,407,410],{"class":340,"line":403},5,[338,405,406],{"class":355},"        count",[338,408,409],{"class":344},"++",[338,411,378],{"class":355},[338,413,415],{"class":340,"line":414},6,[338,416,417],{"class":355},"    }\n",[338,419,421],{"class":340,"line":420},7,[338,422,385],{"emptyLinePlaceholder":384},[338,424,426,428,430,433],{"class":340,"line":425},8,[338,427,391],{"class":344},[338,429,365],{"class":344},[338,431,432],{"class":351}," getCount",[338,434,400],{"class":355},[338,436,438,441],{"class":340,"line":437},9,[338,439,440],{"class":344},"        return",[338,442,443],{"class":355}," count;\n",[338,445,447],{"class":340,"line":446},10,[338,448,417],{"class":355},[338,450,452],{"class":340,"line":451},11,[338,453,454],{"class":355},"}\n",[309,456,457,458,460],{},"En este ejemplo, el método ",[320,459,326],{}," no está sincronizado, lo que significa que si varios hilos llaman a este método al mismo tiempo, pueden interferir entre sí y producir un resultado incorrecto.",[309,462,463,464,466],{},"Para emular esta condición de carrera, podemos crear varios hilos que llamen al método ",[320,465,326],{}," simultáneamente:",[329,468,470],{"className":331,"code":469,"language":333,"meta":334,"style":334},"public class RaceConditionExample {\n    void main() throws InterruptedException {\n        Counter counter = new Counter();\n        Thread thread1 = new Thread(() -> {\n            for (int i = 0; i \u003C 1000; i++) {\n                counter.increment();\n            }\n        });\n        Thread thread2 = new Thread(() -> {\n            for (int i = 0; i \u003C 1000; i++) {\n                counter.increment();\n            }\n        });\n\n        thread1.start();\n        thread2.start();\n\n        thread1.join();\n        thread2.join();\n\n        IO.println(\"Final count: \" + counter.getCount());\n    }\n}\n",[320,471,472,483,500,515,535,570,580,585,590,607,633,641,646,651,656,667,677,682,692,701,706,734,739],{"__ignoreMap":334},[338,473,474,476,478,481],{"class":340,"line":341},[338,475,345],{"class":344},[338,477,348],{"class":344},[338,479,480],{"class":351}," RaceConditionExample",[338,482,356],{"class":355},[338,484,485,488,491,494,497],{"class":340,"line":359},[338,486,487],{"class":344},"    void",[338,489,490],{"class":351}," main",[338,492,493],{"class":355},"() ",[338,495,496],{"class":344},"throws",[338,498,499],{"class":355}," InterruptedException {\n",[338,501,502,505,507,510,512],{"class":340,"line":381},[338,503,504],{"class":355},"        Counter counter ",[338,506,371],{"class":344},[338,508,509],{"class":344}," new",[338,511,352],{"class":351},[338,513,514],{"class":355},"();\n",[338,516,517,520,522,524,527,530,533],{"class":340,"line":388},[338,518,519],{"class":355},"        Thread thread1 ",[338,521,371],{"class":344},[338,523,509],{"class":344},[338,525,526],{"class":351}," Thread",[338,528,529],{"class":355},"(() ",[338,531,532],{"class":344},"->",[338,534,356],{"class":355},[338,536,537,540,543,546,549,551,553,556,559,562,565,567],{"class":340,"line":403},[338,538,539],{"class":344},"            for",[338,541,542],{"class":355}," (",[338,544,545],{"class":344},"int",[338,547,548],{"class":355}," i ",[338,550,371],{"class":344},[338,552,375],{"class":374},[338,554,555],{"class":355},"; i ",[338,557,558],{"class":344},"\u003C",[338,560,561],{"class":374}," 1000",[338,563,564],{"class":355},"; i",[338,566,409],{"class":344},[338,568,569],{"class":355},") {\n",[338,571,572,575,578],{"class":340,"line":414},[338,573,574],{"class":355},"                counter.",[338,576,577],{"class":351},"increment",[338,579,514],{"class":355},[338,581,582],{"class":340,"line":420},[338,583,584],{"class":355},"            }\n",[338,586,587],{"class":340,"line":425},[338,588,589],{"class":355},"        });\n",[338,591,592,595,597,599,601,603,605],{"class":340,"line":437},[338,593,594],{"class":355},"        Thread thread2 ",[338,596,371],{"class":344},[338,598,509],{"class":344},[338,600,526],{"class":351},[338,602,529],{"class":355},[338,604,532],{"class":344},[338,606,356],{"class":355},[338,608,609,611,613,615,617,619,621,623,625,627,629,631],{"class":340,"line":446},[338,610,539],{"class":344},[338,612,542],{"class":355},[338,614,545],{"class":344},[338,616,548],{"class":355},[338,618,371],{"class":344},[338,620,375],{"class":374},[338,622,555],{"class":355},[338,624,558],{"class":344},[338,626,561],{"class":374},[338,628,564],{"class":355},[338,630,409],{"class":344},[338,632,569],{"class":355},[338,634,635,637,639],{"class":340,"line":451},[338,636,574],{"class":355},[338,638,577],{"class":351},[338,640,514],{"class":355},[338,642,644],{"class":340,"line":643},12,[338,645,584],{"class":355},[338,647,649],{"class":340,"line":648},13,[338,650,589],{"class":355},[338,652,654],{"class":340,"line":653},14,[338,655,385],{"emptyLinePlaceholder":384},[338,657,659,662,665],{"class":340,"line":658},15,[338,660,661],{"class":355},"        thread1.",[338,663,664],{"class":351},"start",[338,666,514],{"class":355},[338,668,670,673,675],{"class":340,"line":669},16,[338,671,672],{"class":355},"        thread2.",[338,674,664],{"class":351},[338,676,514],{"class":355},[338,678,680],{"class":340,"line":679},17,[338,681,385],{"emptyLinePlaceholder":384},[338,683,685,687,690],{"class":340,"line":684},18,[338,686,661],{"class":355},[338,688,689],{"class":351},"join",[338,691,514],{"class":355},[338,693,695,697,699],{"class":340,"line":694},19,[338,696,672],{"class":355},[338,698,689],{"class":351},[338,700,514],{"class":355},[338,702,704],{"class":340,"line":703},20,[338,705,385],{"emptyLinePlaceholder":384},[338,707,709,712,715,718,722,725,728,731],{"class":340,"line":708},21,[338,710,711],{"class":355},"        IO.",[338,713,714],{"class":351},"println",[338,716,717],{"class":355},"(",[338,719,721],{"class":720},"sU2Wk","\"Final count: \"",[338,723,724],{"class":344}," +",[338,726,727],{"class":355}," counter.",[338,729,730],{"class":351},"getCount",[338,732,733],{"class":355},"());\n",[338,735,737],{"class":340,"line":736},22,[338,738,417],{"class":355},[338,740,742],{"class":340,"line":741},23,[338,743,454],{"class":355},[309,745,746,747,749],{},"En este ejemplo, hemos creado dos hilos que incrementan el contador 1000 veces cada uno. Debido a la falta de sincronización en el método ",[320,748,326],{},", es posible que el resultado final no sea 2000, sino un número menor debido a la interferencia entre los hilos.",[304,751,753],{"id":752},"resolución-de-la-condición-de-carrera","Resolución de la condición de carrera",[309,755,756,757,759],{},"Para resolver la condición de carrera, podemos sincronizar el método ",[320,758,326],{}," para asegurarnos de que solo un hilo pueda acceder a él a la vez:",[329,761,763],{"className":331,"code":762,"language":333,"meta":334,"style":334},"public class Counter {\n    private int count = 0;\n\n    public synchronized void increment() {\n        count++;\n    }\n\n    public int getCount() {\n        return count;\n    }\n}\n",[320,764,765,775,789,793,806,814,818,822,832,838,842],{"__ignoreMap":334},[338,766,767,769,771,773],{"class":340,"line":341},[338,768,345],{"class":344},[338,770,348],{"class":344},[338,772,352],{"class":351},[338,774,356],{"class":355},[338,776,777,779,781,783,785,787],{"class":340,"line":359},[338,778,362],{"class":344},[338,780,365],{"class":344},[338,782,368],{"class":355},[338,784,371],{"class":344},[338,786,375],{"class":374},[338,788,378],{"class":355},[338,790,791],{"class":340,"line":381},[338,792,385],{"emptyLinePlaceholder":384},[338,794,795,797,800,802,804],{"class":340,"line":388},[338,796,391],{"class":344},[338,798,799],{"class":344}," synchronized",[338,801,394],{"class":344},[338,803,397],{"class":351},[338,805,400],{"class":355},[338,807,808,810,812],{"class":340,"line":403},[338,809,406],{"class":355},[338,811,409],{"class":344},[338,813,378],{"class":355},[338,815,816],{"class":340,"line":414},[338,817,417],{"class":355},[338,819,820],{"class":340,"line":420},[338,821,385],{"emptyLinePlaceholder":384},[338,823,824,826,828,830],{"class":340,"line":425},[338,825,391],{"class":344},[338,827,365],{"class":344},[338,829,432],{"class":351},[338,831,400],{"class":355},[338,833,834,836],{"class":340,"line":437},[338,835,440],{"class":344},[338,837,443],{"class":355},[338,839,840],{"class":340,"line":446},[338,841,417],{"class":355},[338,843,844],{"class":340,"line":451},[338,845,454],{"class":355},[309,847,848,849,852,853,855],{},"Al agregar la palabra clave ",[320,850,851],{},"synchronized"," al método ",[320,854,326],{},", garantizamos que solo un hilo pueda acceder a este método a la vez, lo que evita la condición de carrera y asegura que el resultado final sea siempre 2000.",[857,858,859],"warning",{},"Es importante tener en cuenta que la sincronización puede afectar el rendimiento de la aplicación, ya que introduce un bloqueo que puede ralentizar la ejecución de los hilos. Por lo tanto, es crucial utilizar la sincronización de manera adecuada y solo cuando sea necesario para evitar condiciones de carrera.",[861,862,864],"h3",{"id":863},"alternativas-a-la-sincronización","Alternativas a la sincronización",[309,866,867,868,871,872,875],{},"Además de la sincronización, existen otras alternativas para evitar condiciones de carrera, como el uso de variables atómicas (",[320,869,870],{},"AtomicInteger",") o el uso de bloqueos explícitos (",[320,873,874],{},"ReentrantLock","). Estas alternativas pueden ofrecer un mejor rendimiento en ciertos casos, pero es importante entender las implicaciones de cada enfoque y elegir el adecuado según las necesidades de tu aplicación.",[304,877,879],{"id":878},"usando-atributos-sincronizados","Usando atributos sincronizados",[309,881,882,883,886],{},"Otra forma de evitar condiciones de carrera es utilizando atributos sincronizados. En Java, podemos declarar un atributo como ",[320,884,885],{},"volatile"," para garantizar que los cambios realizados por un hilo sean visibles para otros hilos. Sin embargo, esto no garantiza la atomicidad de las operaciones, por lo que es importante usarlo con precaución.",[329,888,890],{"className":331,"code":889,"language":333,"meta":334,"style":334},"public class Counter {\n    private volatile int count = 0;\n\n    public void increment() {\n        count++;\n    }\n\n    public int getCount() {\n        return count;\n    }\n}\n",[320,891,892,902,919,923,933,941,945,949,959,965,969],{"__ignoreMap":334},[338,893,894,896,898,900],{"class":340,"line":341},[338,895,345],{"class":344},[338,897,348],{"class":344},[338,899,352],{"class":351},[338,901,356],{"class":355},[338,903,904,906,909,911,913,915,917],{"class":340,"line":359},[338,905,362],{"class":344},[338,907,908],{"class":344}," volatile",[338,910,365],{"class":344},[338,912,368],{"class":355},[338,914,371],{"class":344},[338,916,375],{"class":374},[338,918,378],{"class":355},[338,920,921],{"class":340,"line":381},[338,922,385],{"emptyLinePlaceholder":384},[338,924,925,927,929,931],{"class":340,"line":388},[338,926,391],{"class":344},[338,928,394],{"class":344},[338,930,397],{"class":351},[338,932,400],{"class":355},[338,934,935,937,939],{"class":340,"line":403},[338,936,406],{"class":355},[338,938,409],{"class":344},[338,940,378],{"class":355},[338,942,943],{"class":340,"line":414},[338,944,417],{"class":355},[338,946,947],{"class":340,"line":420},[338,948,385],{"emptyLinePlaceholder":384},[338,950,951,953,955,957],{"class":340,"line":425},[338,952,391],{"class":344},[338,954,365],{"class":344},[338,956,432],{"class":351},[338,958,400],{"class":355},[338,960,961,963],{"class":340,"line":437},[338,962,440],{"class":344},[338,964,443],{"class":355},[338,966,967],{"class":340,"line":446},[338,968,417],{"class":355},[338,970,971],{"class":340,"line":451},[338,972,454],{"class":355},[309,974,975,976,979,980,982,983,985],{},"En este ejemplo, el atributo ",[320,977,978],{},"count"," es declarado como ",[320,981,885],{},", lo que garantiza que los cambios realizados por un hilo sean visibles para otros hilos. Sin embargo, debido a que la operación de incremento no es atómica, todavía existe la posibilidad de una condición de carrera. Por lo tanto, es importante considerar cuidadosamente el uso de ",[320,984,885],{}," y asegurarse de que se utilice en situaciones donde sea apropiado.",[304,987,989],{"id":988},"conclusión","Conclusión",[309,991,992],{},"En resumen, las condiciones de carrera son un problema común en la programación concurrente que puede llevar a resultados impredecibles. Es crucial entender cómo emular y resolver las condiciones de carrera utilizando mecanismos de sincronización adecuados, como bloqueos o variables atómicas, para garantizar que tu aplicación funcione de manera eficiente y confiable. Además, es importante considerar las implicaciones de cada enfoque y elegir el adecuado según las necesidades de tu aplicación.",[994,995,996],"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 .sDLfK, html code.shiki .sDLfK{--shiki-default:#79B8FF}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 .sU2Wk, html code.shiki .sU2Wk{--shiki-default:#9ECBFF}",{"title":334,"searchDepth":359,"depth":359,"links":998},[999,1000,1001,1004,1005],{"id":306,"depth":359,"text":307},{"id":314,"depth":359,"text":315},{"id":752,"depth":359,"text":753,"children":1002},[1003],{"id":863,"depth":381,"text":864},{"id":878,"depth":359,"text":879},{"id":988,"depth":359,"text":989},"En este artículo se explicará cómo emular condiciones de carrera en Java, utilizando un ejemplo práctico para ilustrar el concepto y las consecuencias de las condiciones de carrera en la programación concurrente.","md",null,{"editButton":104},{"icon":83},{"title":133,"description":1006},"HyQnI0vHewqDNEPvBT3vd2zu-3hICslyVu5USW5baBY",[1014,1016],{"title":129,"path":130,"stem":131,"description":1015,"icon":83,"children":-1},"Problemas comunes en la programación concurrente",{"title":137,"path":138,"stem":139,"description":1017,"icon":83,"children":-1},"En este artículo se explicará qué son los semáforos en Java, cómo funcionan y cómo se pueden utilizar para controlar el acceso a recursos compartidos en la programación concurrente.",1775101372920]