Este documento introduce los conceptos básicos de la programación multihilo en Java, incluyendo la creación de hilos que extienden la clase Thread o implementan la interfaz Runnable, los diferentes estados de un hilo, y cómo sincronizar el acceso a recursos compartidos para evitar errores. También explica la planificación de hilos y la asignación de prioridades.
El documento habla sobre hilos en Java. Explica que un hilo es un flujo de ejecución y que su uso conlleva riesgos de concurrencia. Describe cómo definir e iniciar un hilo que herede de Thread o implemente Runnable. También cubre el ciclo de vida de los hilos, la interrupción, el bloqueo con sleep, y la necesidad de sincronización para evitar inconsistencias al acceder a datos compartidos.
Este documento describe los conceptos básicos de los hilos en Java, incluyendo las clases relacionadas como Thread, Runnable y ThreadGroup. Explica cómo crear hilos extendiendo la clase Thread o implementando la interfaz Runnable, y cubre temas como el estado, control, planificación y sincronización de los hilos.
El documento describe los conceptos de threads y programación multithread en Java. Específicamente, explica que (1) los threads comparten recursos y permiten la ejecución concurrente de tareas, a diferencia de los procesos que son independientes, y (2) Java permite la creación explícita de threads para lograr mayor flexibilidad y rendimiento en aplicaciones.
El documento describe las diferencias entre procesos y hilos en Java. Un proceso es un programa que se ejecuta de forma independiente con su propia memoria, mientras que un hilo es una secuencia de ejecución dentro de un proceso. La JVM permite ejecutar múltiples hilos simultáneamente dentro de un solo proceso, compartiendo los recursos como la memoria. Se explican conceptos como la creación de hilos, sus estados de vida, y métodos como start(), join(), yield(), sleep() y stop(). Finalmente, se mencionan algunos errores comunes rel
El documento explica conceptos relacionados con hilos (threads) en Java. Define un hilo como un flujo de ejecución secuencial dentro de un proceso. Explica cómo crear e implementar hilos, así como los diferentes estados por los que pasan los hilos durante su ciclo de vida. También cubre temas como la sincronización de hilos y el uso de grupos de hilos.
Continuando con la introducción al mundo de los Thread en Java
Se pueden encontrar algunos ejemplos en https://github.com/ldebello/javacuriosities/tree/master/Threads
El documento describe las diferencias entre procesos y hilos en la programación concurrente. Un proceso tiene sus propios recursos privados como memoria, mientras que los hilos comparten los recursos de un proceso. En Java, la programación concurrente se basa principalmente en hilos. La clase Thread permite crear nuevos hilos que ejecutan el método run() de forma concurrente al hilo principal. También es posible implementar la interfaz Runnable para crear hilos sin heredar de Thread.
El documento habla sobre hilos en Java. Explica que un hilo es un flujo de ejecución y que su uso conlleva riesgos de concurrencia. Describe cómo definir e iniciar un hilo que herede de Thread o implemente Runnable. También cubre el ciclo de vida de los hilos, la interrupción, el bloqueo con sleep, y la necesidad de sincronización para evitar inconsistencias al acceder a datos compartidos.
Este documento describe los conceptos básicos de los hilos en Java, incluyendo las clases relacionadas como Thread, Runnable y ThreadGroup. Explica cómo crear hilos extendiendo la clase Thread o implementando la interfaz Runnable, y cubre temas como el estado, control, planificación y sincronización de los hilos.
El documento describe los conceptos de threads y programación multithread en Java. Específicamente, explica que (1) los threads comparten recursos y permiten la ejecución concurrente de tareas, a diferencia de los procesos que son independientes, y (2) Java permite la creación explícita de threads para lograr mayor flexibilidad y rendimiento en aplicaciones.
El documento describe las diferencias entre procesos y hilos en Java. Un proceso es un programa que se ejecuta de forma independiente con su propia memoria, mientras que un hilo es una secuencia de ejecución dentro de un proceso. La JVM permite ejecutar múltiples hilos simultáneamente dentro de un solo proceso, compartiendo los recursos como la memoria. Se explican conceptos como la creación de hilos, sus estados de vida, y métodos como start(), join(), yield(), sleep() y stop(). Finalmente, se mencionan algunos errores comunes rel
El documento explica conceptos relacionados con hilos (threads) en Java. Define un hilo como un flujo de ejecución secuencial dentro de un proceso. Explica cómo crear e implementar hilos, así como los diferentes estados por los que pasan los hilos durante su ciclo de vida. También cubre temas como la sincronización de hilos y el uso de grupos de hilos.
Continuando con la introducción al mundo de los Thread en Java
Se pueden encontrar algunos ejemplos en https://github.com/ldebello/javacuriosities/tree/master/Threads
El documento describe las diferencias entre procesos y hilos en la programación concurrente. Un proceso tiene sus propios recursos privados como memoria, mientras que los hilos comparten los recursos de un proceso. En Java, la programación concurrente se basa principalmente en hilos. La clase Thread permite crear nuevos hilos que ejecutan el método run() de forma concurrente al hilo principal. También es posible implementar la interfaz Runnable para crear hilos sin heredar de Thread.
Este documento describe conceptos clave relacionados con procesos cooperativos y comunicación entre procesos en sistemas operativos. Explica que los procesos pueden ser independientes o cooperativos si comparten datos u objetivos. También describe varios métodos para la comunicación entre procesos, como la comunicación directa e indirecta a través de mensajes y buzones. Además, aborda conceptos como la sincronización, los hilos de usuario y kernel, y soluciones para garantizar la exclusión mutua en las secciones críticas.
El documento trata sobre hilos (threads) en Java. Explica que un hilo es un flujo de ejecución independiente que puede ejecutarse en paralelo a otros. Detalla la clase Thread de Java y cómo crear e implementar hilos heredando de Thread o implementando la interfaz Runnable. También cubre conceptos como el ciclo de vida de los hilos y la sincronización.
Este documento discute los conceptos de multiprocesos y multihilos. Multiprocesos se refiere a varios programas que se ejecutan simultáneamente bajo el control del sistema operativo, mientras que multihilos se refiere a tareas dentro de un solo programa que se ejecutan simultáneamente. El documento también explica cómo crear y controlar hilos mediante la clase Thread en Java.
Este documento explica los conceptos básicos de multitarea e hilos en Java. La multitarea permite ejecutar varios procesos de forma concurrente para mejorar el rendimiento. En Java, los hilos se implementan utilizando la clase Thread o la interfaz Runnable. El documento incluye un ejemplo de cajeras procesando compras de clientes de forma secuencial y paralela usando hilos.
La clase Thread permite crear hilos de ejecución concurrentes en Java. Para crear un hilo, una clase debe extender Thread y redefinir el método run(), el cual especifica la tarea concurrente. Se inicia un hilo mediante el método start(), el cual invoca a run() y devuelve el control. Los hilos comparten los recursos de un proceso y pasan por diferentes estados como nuevo, ejecutable y muerto.
El documento contiene varios ejercicios sobre el uso de hilos en Java. El primer ejercicio crea tres hilos que imprimen su nombre después de un retardo aleatorio. El segundo ejercicio muestra cómo crear un hilo para actualizar un contador en un applet Java. Los ejercicios posteriores presentan ejemplos más complejos de hilos para simular cajeras atendiendo clientes y animales compitiendo en una carrera.
El documento trata sobre conceptos básicos de programación concurrente en Java como agrupamiento de hilos, la clase ThreadGroup y sus métodos, concurrencia y sincronización utilizando monitores synchronized, hilos demonio y el recolector de basura. Explica que los grupos de hilos permiten manipular colectivamente los hilos, la clase ThreadGroup incluye métodos para administrar y operar sobre grupos y hilos, y synchronized garantiza exclusión mutua en secciones críticas.
Este documento describe los hilos en Java. Los hilos, también conocidos como procesos ligeros, permiten la ejecución concurrente dentro de un programa. La clase Thread de Java proporciona funciones para la gestión de hilos. Cada hilo tiene un comienzo, una secuencia de ejecución y un final. El método run() define la lógica del hilo y cuando termina este método, termina el hilo.
La clase Timer se utiliza para crear hilos basados en planificación. Se pueden programar tareas usando la clase TimerTask, la cual extiende la clase Runnable. Las tareas se pueden programar para ejecutarse una sola vez o repetidamente cada cierto periodo de tiempo. El ejemplo muestra cómo programar una tarea para forzar la recolección de basura cada 5 segundos usando las clases Timer y TimerTask.
Un hilo es un subproceso dentro de un proceso que ocupa sus propios recursos. Los grupos de hilos permiten ejecutar múltiples tareas simultáneas. Los servicios POSIX son llamadas al sistema relacionadas con los hilos. Los hilos permiten estructurar las aplicaciones de forma modular y acelerar la ejecución mediante el uso concurrente de los recursos del sistema.
En esta presentación cubrimos el modelo de memoria del JDK 5/6/7, a partir de JDK 8 hay un cambio en el modelo de memoria, así que no toda la presentación seria valida, aunque algunos conceptos se mantienen.
Los ejemplos se pueden encontrar en https://github.com/ldebello/javacuriosities/tree/master/MemoryManagement
El documento describe conceptos básicos de programación concurrente y paralela en Java como hilos, sincronización y prioridades. Explica que los hilos son unidades básicas de ejecución que comparten memoria dentro de un proceso y que Java se enfoca más en hilos que en procesos. También cubre temas como la creación de hilos, su planificación, sincronización para evitar problemas de acceso a recursos compartidos y métodos para controlar su ejecución.
Este módulo cubre los hilos en Java, los cuales permiten que un programa realice múltiples tareas al mismo tiempo. Se explica cómo crear hilos, controlar su ejecución y proteger los datos compartidos. Se definen los hilos, sus estados de ciclo de vida y métodos como wait(), notify() y synchronized. También se describen formas comunes de crear hilos como implementando Runnable o extendiendo Thread.
Este documento trata sobre hilos de ejecución (threads) en Java. Explica conceptos como cómo crear threads extendiendo la clase Thread o implementando Runnable, los diferentes estados de un thread, y métodos como start(), sleep(), yield() e interrupt(). También cubre sincronización, deadlocks, y la interacción entre threads mediante wait() y notify().
El documento trata sobre multithreading en Java. Explica conceptos como crear hilos extendiendo la clase Thread o implementando la interfaz Runnable, y controlar hilos mediante métodos como start(), sleep(), yield() y join(). También cubre temas como el ciclo de vida de los hilos, sincronización, grupos de hilos y el uso de la clase Timer.
Este documento trata sobre la programación concurrente, que implica la ejecución simultánea de múltiples tareas o procesos. Explica las diferencias entre programa y proceso, y cómo la concurrencia surge cuando dos o más procesos interactúan de forma simultánea, ya sea en un solo procesador o en varios. También describe características clave de los sistemas concurrentes como el orden parcial de ejecución y el comportamiento indeterminista.
El documento describe los conceptos clave detrás de los procesadores superescalares. Estos procesadores pueden ejecutar múltiples instrucciones en paralelo en cada ciclo de reloj explotando el paralelismo a nivel de instrucción. Hacen esto mediante el uso de múltiples unidades funcionales, la capacidad de emitir instrucciones de forma desordenada y la finalización desordenada de las instrucciones, sujeto a las dependencias entre ellas. Esto permite lograr un mayor rendimiento en comparación con los diseños de
En los sistemas multiprogramados se define el proceso como entidad representante de la ejecución de un programa en un determinado contexto; En general, un proceso es un flujo de ejecución, representado básicamente por un contador de programa, y su contexto de ejecución, que puede ser más o menos amplio.
La clase GuessANumber extiende Thread y adivina un número aleatorio entre 1 y 100. El programa ThreadClassDemo crea varios objetos GuessANumber y los ejecuta en hilos separados, demostrando el uso de métodos como start(), join(), setPriority(), y setDaemon().
El documento describe varios mecanismos de comunicación entre procesos en Java, incluyendo sockets TCP y UDP, multicast, URLs y RMI. Los sockets TCP son orientados a conexión mientras que los sockets UDP permiten el envío asíncrono de mensajes. La clase URL encapsula la conexión TCP. RMI permite la invocación remota de operaciones para desarrollar sistemas distribuidos.
La multitarea permite la ejecución simultánea de varias tareas compartiendo un único procesador, mientras que el multiproceso requiere de múltiples procesadores. Java permite la programación multitarea a través de hilos implementados con la clase Thread o la interfaz Runnable. El framework de concurrencia de Java simplifica el desarrollo de aplicaciones multitarea a través de estructuras de datos concurrentes, variables atómicas, bloqueos y otras utilidades.
Este documento presenta una guía sobre el uso de hilos en Java. Explica que un hilo es un flujo de ejecución dentro de un proceso y que Java soporta hilos a través de la clase Thread y la interfaz Runnable. También describe el ciclo de vida de un hilo, incluyendo los estados new, runnable, not running y dead. Además, cubre temas como prioridad de hilos, métodos sincronizados y el uso de la clase ThreadGroup.
Este documento describe conceptos clave relacionados con procesos cooperativos y comunicación entre procesos en sistemas operativos. Explica que los procesos pueden ser independientes o cooperativos si comparten datos u objetivos. También describe varios métodos para la comunicación entre procesos, como la comunicación directa e indirecta a través de mensajes y buzones. Además, aborda conceptos como la sincronización, los hilos de usuario y kernel, y soluciones para garantizar la exclusión mutua en las secciones críticas.
El documento trata sobre hilos (threads) en Java. Explica que un hilo es un flujo de ejecución independiente que puede ejecutarse en paralelo a otros. Detalla la clase Thread de Java y cómo crear e implementar hilos heredando de Thread o implementando la interfaz Runnable. También cubre conceptos como el ciclo de vida de los hilos y la sincronización.
Este documento discute los conceptos de multiprocesos y multihilos. Multiprocesos se refiere a varios programas que se ejecutan simultáneamente bajo el control del sistema operativo, mientras que multihilos se refiere a tareas dentro de un solo programa que se ejecutan simultáneamente. El documento también explica cómo crear y controlar hilos mediante la clase Thread en Java.
Este documento explica los conceptos básicos de multitarea e hilos en Java. La multitarea permite ejecutar varios procesos de forma concurrente para mejorar el rendimiento. En Java, los hilos se implementan utilizando la clase Thread o la interfaz Runnable. El documento incluye un ejemplo de cajeras procesando compras de clientes de forma secuencial y paralela usando hilos.
La clase Thread permite crear hilos de ejecución concurrentes en Java. Para crear un hilo, una clase debe extender Thread y redefinir el método run(), el cual especifica la tarea concurrente. Se inicia un hilo mediante el método start(), el cual invoca a run() y devuelve el control. Los hilos comparten los recursos de un proceso y pasan por diferentes estados como nuevo, ejecutable y muerto.
El documento contiene varios ejercicios sobre el uso de hilos en Java. El primer ejercicio crea tres hilos que imprimen su nombre después de un retardo aleatorio. El segundo ejercicio muestra cómo crear un hilo para actualizar un contador en un applet Java. Los ejercicios posteriores presentan ejemplos más complejos de hilos para simular cajeras atendiendo clientes y animales compitiendo en una carrera.
El documento trata sobre conceptos básicos de programación concurrente en Java como agrupamiento de hilos, la clase ThreadGroup y sus métodos, concurrencia y sincronización utilizando monitores synchronized, hilos demonio y el recolector de basura. Explica que los grupos de hilos permiten manipular colectivamente los hilos, la clase ThreadGroup incluye métodos para administrar y operar sobre grupos y hilos, y synchronized garantiza exclusión mutua en secciones críticas.
Este documento describe los hilos en Java. Los hilos, también conocidos como procesos ligeros, permiten la ejecución concurrente dentro de un programa. La clase Thread de Java proporciona funciones para la gestión de hilos. Cada hilo tiene un comienzo, una secuencia de ejecución y un final. El método run() define la lógica del hilo y cuando termina este método, termina el hilo.
La clase Timer se utiliza para crear hilos basados en planificación. Se pueden programar tareas usando la clase TimerTask, la cual extiende la clase Runnable. Las tareas se pueden programar para ejecutarse una sola vez o repetidamente cada cierto periodo de tiempo. El ejemplo muestra cómo programar una tarea para forzar la recolección de basura cada 5 segundos usando las clases Timer y TimerTask.
Un hilo es un subproceso dentro de un proceso que ocupa sus propios recursos. Los grupos de hilos permiten ejecutar múltiples tareas simultáneas. Los servicios POSIX son llamadas al sistema relacionadas con los hilos. Los hilos permiten estructurar las aplicaciones de forma modular y acelerar la ejecución mediante el uso concurrente de los recursos del sistema.
En esta presentación cubrimos el modelo de memoria del JDK 5/6/7, a partir de JDK 8 hay un cambio en el modelo de memoria, así que no toda la presentación seria valida, aunque algunos conceptos se mantienen.
Los ejemplos se pueden encontrar en https://github.com/ldebello/javacuriosities/tree/master/MemoryManagement
El documento describe conceptos básicos de programación concurrente y paralela en Java como hilos, sincronización y prioridades. Explica que los hilos son unidades básicas de ejecución que comparten memoria dentro de un proceso y que Java se enfoca más en hilos que en procesos. También cubre temas como la creación de hilos, su planificación, sincronización para evitar problemas de acceso a recursos compartidos y métodos para controlar su ejecución.
Este módulo cubre los hilos en Java, los cuales permiten que un programa realice múltiples tareas al mismo tiempo. Se explica cómo crear hilos, controlar su ejecución y proteger los datos compartidos. Se definen los hilos, sus estados de ciclo de vida y métodos como wait(), notify() y synchronized. También se describen formas comunes de crear hilos como implementando Runnable o extendiendo Thread.
Este documento trata sobre hilos de ejecución (threads) en Java. Explica conceptos como cómo crear threads extendiendo la clase Thread o implementando Runnable, los diferentes estados de un thread, y métodos como start(), sleep(), yield() e interrupt(). También cubre sincronización, deadlocks, y la interacción entre threads mediante wait() y notify().
El documento trata sobre multithreading en Java. Explica conceptos como crear hilos extendiendo la clase Thread o implementando la interfaz Runnable, y controlar hilos mediante métodos como start(), sleep(), yield() y join(). También cubre temas como el ciclo de vida de los hilos, sincronización, grupos de hilos y el uso de la clase Timer.
Este documento trata sobre la programación concurrente, que implica la ejecución simultánea de múltiples tareas o procesos. Explica las diferencias entre programa y proceso, y cómo la concurrencia surge cuando dos o más procesos interactúan de forma simultánea, ya sea en un solo procesador o en varios. También describe características clave de los sistemas concurrentes como el orden parcial de ejecución y el comportamiento indeterminista.
El documento describe los conceptos clave detrás de los procesadores superescalares. Estos procesadores pueden ejecutar múltiples instrucciones en paralelo en cada ciclo de reloj explotando el paralelismo a nivel de instrucción. Hacen esto mediante el uso de múltiples unidades funcionales, la capacidad de emitir instrucciones de forma desordenada y la finalización desordenada de las instrucciones, sujeto a las dependencias entre ellas. Esto permite lograr un mayor rendimiento en comparación con los diseños de
En los sistemas multiprogramados se define el proceso como entidad representante de la ejecución de un programa en un determinado contexto; En general, un proceso es un flujo de ejecución, representado básicamente por un contador de programa, y su contexto de ejecución, que puede ser más o menos amplio.
La clase GuessANumber extiende Thread y adivina un número aleatorio entre 1 y 100. El programa ThreadClassDemo crea varios objetos GuessANumber y los ejecuta en hilos separados, demostrando el uso de métodos como start(), join(), setPriority(), y setDaemon().
El documento describe varios mecanismos de comunicación entre procesos en Java, incluyendo sockets TCP y UDP, multicast, URLs y RMI. Los sockets TCP son orientados a conexión mientras que los sockets UDP permiten el envío asíncrono de mensajes. La clase URL encapsula la conexión TCP. RMI permite la invocación remota de operaciones para desarrollar sistemas distribuidos.
La multitarea permite la ejecución simultánea de varias tareas compartiendo un único procesador, mientras que el multiproceso requiere de múltiples procesadores. Java permite la programación multitarea a través de hilos implementados con la clase Thread o la interfaz Runnable. El framework de concurrencia de Java simplifica el desarrollo de aplicaciones multitarea a través de estructuras de datos concurrentes, variables atómicas, bloqueos y otras utilidades.
Este documento presenta una guía sobre el uso de hilos en Java. Explica que un hilo es un flujo de ejecución dentro de un proceso y que Java soporta hilos a través de la clase Thread y la interfaz Runnable. También describe el ciclo de vida de un hilo, incluyendo los estados new, runnable, not running y dead. Además, cubre temas como prioridad de hilos, métodos sincronizados y el uso de la clase ThreadGroup.
Un hilo es una tarea que puede ejecutarse simultáneamente con otras tareas. Los hilos comparten recursos como memoria y archivos con otros hilos dentro de un mismo proceso, pero cada hilo tiene su propio contador de programa y estado de CPU. Los hilos pueden cambiar entre estados como ejecución, listo y bloqueado.
Este material didáctico fue desarrollado para la asignatura de Tópicos Avanzados de Programación, del plan SCD-1027 2016 de Ing. En Sistemas Computacionales
Este documento presenta información sobre programación concurrente utilizando hilos. Explica conceptos como hilos, clases Thread y Monitor, y métodos para la sincronización de hilos como lock, wait y pulse. También presenta ejemplos de código para crear y manejar hilos, y describe problemas como el problema de los filósofos comensales que requieren sincronización de hilos.
Este documento describe los conceptos básicos de los hilos en Java, incluyendo las clases relacionadas como Thread, Runnable y ThreadGroup. Explica cómo crear e implementar hilos en Java y cómo controlar y sincronizar su estado y ejecución. También cubre temas como la planificación, prioridad y agrupamiento de hilos.
Unidad 4 tópicos avanzados de programación Irving Che
Este documento describe los conceptos básicos de la programación concurrente multihilos. Explica que un hilo es la unidad de ejecución de un proceso y puede encontrarse en diferentes estados como nuevo, preparado, en ejecución, bloqueado o dormido. También describe los programas de flujo único frente a los programas multihilos y la importancia de la sincronización cuando se usan múltiples hilos para acceder a recursos compartidos.
Este documento presenta información sobre procesos y threads. Explica que los procesos son programas en ejecución identificados por un PID, mientras que los threads son unidades mínimas de trabajo que comparten el espacio de direcciones de un proceso. También describe herramientas para la sincronización de threads como mutexes y semáforos, e indica que el módulo threading de Python soporta la programación concurrente mediante threads mientras que multiprocessing permite la ejecución de procesos en paralelo.
Este documento presenta conceptos sobre programación concurrente y hilos. Explica que un hilo es un proceso que se ejecuta en el sistema operativo y que permiten dividir tareas complejas en subtareas concurrentes. Describe métodos para crear, detener y sincronizar hilos. Finalmente, presenta el problema clásico de los filósofos comensales como ejemplo de uso de recursos compartidos y sincronización entre hilos.
Las ventajas de los hilos en Java incluyen que toman menos tiempo para crear y cerrar que los procesos, permiten una comunicación más sencilla entre tareas, y pueden ejecutar múltiples tareas simultáneamente para obtener resultados más rápidos. Las desventajas son que cuando un hilo realiza una llamada al sistema, bloquea a todos los demás hilos del proceso; una mala sincronización entre hilos puede causar inconsistencia de datos; y los hilos dependen más del programa principal que los procesos para recursos.
El documento describe conceptos relacionados con hilos y procesos en programación concurrente. Explica que un hilo es la unidad mínima de ejecución dentro de un proceso, y que los hilos comparten memoria dentro de un proceso. También describe algunas propiedades y métodos de la clase Thread de .NET para crear e iniciar hilos, así como conceptos como estados de hilos y sincronización.
El documento describe conceptos básicos sobre procesos y sistemas operativos, incluyendo las definiciones de proceso, estados de procesos, control de procesos, hilos, y principios de concurrencia. Explica que un proceso es una instancia de ejecución de un programa y puede estar en estados como activo, preparado, bloqueado o suspendido. También cubre temas como la creación de jerarquías de procesos, la protección del sistema operativo a través de modos de privilegio, y los desafíos de la concurrencia al
Este documento resume la Unidad IV de programación concurrente (multihilo). Explica conceptos clave como hilos, estados de hilos, programas de flujo único, creación y control de hilos, y sincronización de hilos a través del uso de métodos synchronized y declaraciones synchronized.
OpenMP es una interfaz para programación paralela de memoria compartida. Permite definir regiones de código que se ejecutan en paralelo a través de directivas. Las directivas más comunes son parallel para definir regiones paralelas y for para distribuir iteraciones de bucles entre hilos. Code::Blocks es un entorno de desarrollo que soporta OpenMP mediante la instalación del compilador MinGW con la biblioteca OpenMP.
Un hilo es la unidad más elemental de un proceso y representa una secuencia de instrucciones que se ejecutan en el procesador. Los hilos comparten recursos dentro de un mismo proceso y pueden ejecutarse de forma concurrente para aprovechar mejor los recursos. El uso de hilos tiene ventajas como menor tiempo de creación, cambio y comunicación entre tareas en comparación con procesos.
Un thread es un proceso ligero o tarea que se ejecuta dentro de un programa. Pueden existir múltiples threads ejecutándose simultáneamente. Los threads comparten los recursos del programa y cada uno tiene un flujo secuencial de control. Existen dos métodos para crear threads en Java: extendiendo la clase Thread e implementando la interfaz Runnable.
Un thread es un proceso ligero o tarea que se ejecuta dentro de un programa. Pueden existir múltiples threads ejecutándose simultáneamente. Los threads comparten los recursos del programa y cada uno tiene un flujo secuencial de control. Existen dos métodos para crear threads en Java: extendiendo la clase Thread e implementando la interfaz Runnable.
Este documento celebra el 10o aniversario de la revista AtixLibre. Explica que mantener un proyecto a largo plazo es difícil, pero que AtixLibre ha logrado mantener su compromiso de compartir conocimiento de forma libre. También destaca que han aprendido mucho durante este tiempo y han podido cumplir su objetivo de dejar una huella en las vidas de otras personas a través de su contenido educativo.
Este documento celebra el 10o aniversario de la revista AtixLibre. Explica que mantener un proyecto a largo plazo es difícil, pero que AtixLibre ha logrado mantenerse firme en su misión de compartir conocimiento de forma libre. También destaca que a lo largo de los años, tanto los autores como los lectores de la revista han aprendido mucho, y que AtixLibre ha cumplido su objetivo de dejar una huella en las vidas de otras personas a través de la difusión del conocimiento.
Este documento presenta un libro titulado "De Windows a Linux" que guía a los lectores en realizar una migración desde Windows hacia Linux utilizando la distribución Ubuntu. El libro explica conceptos básicos de software libre y Linux, muestra cómo probar un sistema Linux desde Windows, guía el proceso de migración, introduce Ubuntu y muestra cómo usarlo para trabajo, multimedia, diseño e Internet.
La guia secreta de harry potter el cronista de salemLaboratorios ACME
Este documento resume la información adicional y los detalles sobre el universo de Harry Potter que la autora J.K. Rowling ha revelado fuera de los libros, incluyendo detalles sobre los personajes, lugares y eventos antes, durante y después de la historia contada en la saga. El documento también proporciona contexto sobre cómo Rowling desarrolló la saga y escribió los libros individuales, así como algunos detalles descartados que no aparecieron en las versiones finales.
Aho alfred compiladores principios tecnicas y herramientasLaboratorios ACME
Este documento describe los detalles de un proyecto de construcción de una carretera. Explica los materiales que se usarán, como concreto y asfalto, el trazado de la carretera y los posibles impactos ambientales. También incluye un cronograma tentativo de la construcción y el presupuesto estimado para completar el proyecto.
Este documento presenta un módulo sobre técnicas avanzadas de desarrollo de videojuegos. Se introducen conceptos de jugabilidad y metodologías de desarrollo, así como aspectos avanzados del lenguaje C++ como la programación genérica y la biblioteca STL. También se describen estructuras de datos no lineales y técnicas de optimización gráfica avanzadas como filtros de partículas y shaders. El módulo complementa los contenidos del Curso de Experto en Desarrollo de Videojuegos impart
Este documento presenta un resumen del módulo "Programación Gráfica" del Curso de Experto en Desarrollo de Videojuegos. El módulo cubre aspectos básicos de la programación gráfica como el pipeline gráfico, las matemáticas subyacentes, el uso de materiales y texturas, la iluminación y los sistemas de partículas. También discute la importancia de la simulación física para dotar de realismo a los objetos y actores en el juego. Finalmente, introduce la biblioteca gráfica OGRE como
Este documento presenta el cuarto módulo del Curso de Experto en Desarrollo de Videojuegos sobre el desarrollo de componentes específicos. El módulo cubre temas como la inteligencia artificial, el juego multijugador en red, el audio, el vídeo y nuevas técnicas de interacción. En la sección de inteligencia artificial, se estudian técnicas como la lógica difusa, los algoritmos genéticos y las redes neuronales, así como algoritmos de búsqueda y planificación de
Este documento presenta el primer libro de una colección de cuatro volúmenes dedicados al desarrollo de videojuegos. El objetivo de este primer libro es proporcionar una visión general de la arquitectura de un motor de videojuegos, incluyendo subsistemas como renderizado, física, audio, entre otros. También cubre conceptos básicos de C++ y herramientas de desarrollo como compilación, depuración y control de versiones. El libro asume conocimientos previos de programación en C/C++ y está dirig
Este documento describe los detalles de un proyecto de construcción de una carretera. Explica los materiales que se usarán, como concreto y asfalto, el trazado de la ruta de 10 millas, y un cronograma tentativo de 18 meses para completar el proyecto.
Este documento presenta una guía para elegir hardware de computadora de acuerdo al uso previsto. Explica que es importante considerar el destino final del equipo, ya sea para oficina, juegos, edición gráfica o de video. Luego, resume las características clave de componentes como motherboard, memoria RAM, disco duro y placa de video según cada uso. También analiza las ventajas y desventajas de la tecnología Blu-ray.
2. Tutorial de Threads
2 de 11
tiempo desciende ya que al propio proceso de los hilos hay que sumar el tiempo de
conmutacion entre ellos.
¿Donde puedo realizar programación multihilo en Java?
En la actualidad casi todos los sistemas operativos proporcian servicios para la programación
multihilo pero el tratamiento por parte de la JVM es algo distinto a como lo realizan estos
sistemas.Todas las JVM de todas las plataforma proporcionan hilos de ejecución aunque el
sistema operatico subyacente no los proporcione,en este caso el JVM simula ese
comportamiento.Sin embargo incluso en sistemas que si admiten este tipo de programación
hasta la versión del JDK 1.2 los hilos de la JVM no se correspondían a hilos nativos del
sistema(excepto en su versión para Solaris) con lo cual el rendimiento del programe en
general se veia gravemente dañado.Sin embargo a partir de esta versión la JVM para entornos
Windos proporciona servicios de hilos nativos(esto es proporcionados por la api Win32 y no
simulados por el sistema) y a partir de la versión 1.3 realiza el mismo tratamiento para
entornos Windows.A parte de estos hilos nativos la JVM en todo caso sigue proporcionando
hilos simulados por ella misma(no nativos) conocidos como hilos verdes(green threads) que
garantizan el mismo comportamiento en todas las plataformas en las que se ejecuten en
cuanto a la cuestión de la planificación(que hilo toma el control del procesador y en qué
momento) pero de un rendimiento sensiblemente mas bajo que los hilos nativos.La decision
de usar uno u otro es cuestión de diseño y se escapa al alcance de este tutorial.
Threads en java
En Java un hilo es una clase que desciende de la clase java.lang.Thread o bien que extiende a
la interfaz Runnable(util en los casos de que la clase ya forme parte de una jerarquia de clases
esto es que ya derive de otra clase).La forma de construccion del hilo(derivación o
implementación) es independiente de su utilización,una vez creados se usan de la misma
forma sea cual sea el metodo de construcción utilizado.En Java un hilo puede encontrarse en
cualquiera de los siguiente estados:
nace
El hilo se declarado pero todavia no se ha dado la
orden de puesta en ejecución.(metodo start()).
listo
El hilo esta preparado para entrar en ejecución pero el
planificador aun no ha decidido su puesta en marcha
ejecutandose El hilo esta ejecutandose en la CPU.
dormido
El hilo se ha detenido durante un instante de tiempo
definido mediante la utilización del metodo sleep().
bloqueado
El hilo está pendiente de una operación de I/O y no
volverá al estado listo hasta que esta termine
suspendido
El hilo ha detenido temporalmente su ejecucion
mediante la utilización del metodo suspend() y no la
reaundará hasta que se llame a
resume().Deprecated,1.2.No debe usarse
esperando
El hilo ha detenido su ejecución debido a una
condición externa o interna mediante la llamada a
wait() y no reanudará esta hasta la llamada al metodo
notify() o notifyAll().
muerto El hilo ha terminado su ejecución bien porque termino
3. Tutorial de Threads
3 de 11
de realizar su trabajo o bien porque se llamó al metodo
stop().Deprecated 1.2.No debe usarse.
A continuación se puede observar el diagrama de estados explicado previamente:
Figura 1.1 Diagrama de estados de un Thread
De todos los metodos que se pueden observar los que no deben utlizarse por estar
desautorizados son stop(), suspend() y resume().Su funcionalidad se ha sustituido por otros
metodo que se describirán más adelante en este tutorial.
Como habiamos dicho un hilo puede crearse extendiendo a la clase Thread o bien
implementando a la interfaz Runnable.En ambos casos la clase debe proporcionar una
definicion del metodo run() que contiene el código a ejecutarse una vez que el hilo entre en
estado de ejecución.Veamos un ejemplo de los dos metodos:
//Clase HiloThread
public class HiloThread extends Thread
{
public void run()
{
while(true)
{
System.out.println("Hola mundo,soy el hilo HiloTread");
}
}
}
//Clase HiloRunnable
public class HiloRunnable implements Runnable
4. Tutorial de Threads
4 de 11
{
public void run()
{
while(true)
{
System.out.println("Hola mundo,soy el hilo HiloRunnable");
}
}
}
Como se observa ambos metodos son esencialmente muy parecidos en su
implementación,pero diferirán algo en su construcción.Bien,ya tengo un par de hilos que
simplemente y de forma indefinida escriben en la consola un mensaje de su propia
ejecución.¿Como los pongo en marcha y como interactúo con ellos?.Para ello definiremos una
nueva clase:
//Clase Test
public class Test
{
public static void main(String[] args)
{
//Creamos un hilo del primer tipo
//y lo ponemos en marcha
HiloThread ht = new HiloTread();
ht.start();
//Creamos un hilo del segundo tipo
//y lo ponemos en marcha
Thread hr = new Thread(new HiloRunnable());
hr.start();
}
}
Como se puede observar ambos hilos se construyen de manera distinta,mientras que el que
desciende de Thread se crea como un objeto más el que implementa Runnable,se crea y se
pasa al constructor de la clase generica Thread.La puesta en marcha se realiza en ambos casos
de forma identica.Se llama al metodo start() y comienza la ejecucion del hilo,mientras no se
llame a este metodo el hilo se encontrará en el estado nacido y una vez llamado el hilo entrará
en la cola de hilos del planificador hasta el momento en el que este decida su
ejecución(recordemos en todo momento hay una seria de hilos compitiendo por el
procesador).
La clase Thread proporciona los siguientes constructores para la utilización de hilos:
Thread()
Thread(Runnable target)
5. Tutorial de Threads
5 de 11
Thread(Runnable target, String name)
Thread(String name)
Thread(ThreadGroup group, Runnable target)
Thread(ThreadGroup group, Runnable target, String name)
Thread(ThreadGroup group, String name)
De todos estos constructores puede haber dos parametros confusos.Uno es String name que se
usa simplemente para dar un nombre el thread de manera que luego pueda referenciarse de
forma externa a la referencia que contiene el objeto thread,de esta manera mediante los
metodos String getName() y void setName(String).El otro parametro es un objeto del tipo
ThreadGroup lo cual merece una explicación mas detallada.
Todo hilo que se este ejecutando en una JVM sin excepciones pertenece a un ThreadGroup,si
no se señala ninguno el thread pertenecerá al grupo de hilos principal o grupo "main".La
división de hilos en grupos permite una gestión y un tratamiento homogeneo a todos los hilos
del grupo como si se tratara de uno solo,pudiendo cambiar su
prioridad,detenerlos,interrumpirlos,enumerarlos,obtener información de su estado...etc etc con
tan solo una orden.La forma de crear hilos que pertenezcan a un mismo grupo es la siguiente.
ThreadGroup group = new ThreadGroup("MiGrupo");
Thread h1 = new Thread(group,new HiloRunnable());
Thread h2 = new Thread(group,new HiloRunnable());
Thread h3 = new Thread(group,new HiloRunnable());
group.list(); //muestra información de todos los hilos del grupo
Planificación de hilos
Un tema fundamental dentro de la programación multihilo es la planificación de los hilos.Este
concepto se refiere a la politica a seguir de qué hilo toma el control del procesador y de
cuando.Obviamente en el caso de que un hilo este bloqueado esperando una operacion de IO
este hilo debería dejar el control del procesador y que este control lo tomara otro hilo que si
pudiera hacer uso del tiempo de CPU.¿Pero que pasa si hay mas de un hilo esperando?.¿A
cual de ellos le otrogamos el control del procesador?.Para determinar esta cuestión cada hilo
posee su propia prioridad,un hilo de prioridad mas alta que se encuentre en el estado listo
entrará antes en el estado de ejecución que otro de menor prioridad.Cada hilo hereda la
prioridad del hilo que lo ha creado,de main si no se crea fuera del metodo run() de otro
hilo,habiendo 10 niveles enteros de prioridad desde 1 a 10,siendo 1 la menor prioridad y 10 la
mayor prioridad.
h1.setPriority(10); //Le concede la mayor prioridad
h2.setPriority(1); //Le concede la menor prioridad
Tambien existen constantes definidas para la asignación de prioridad estas son :
MIN_PRIORITY=1
NORM_PRIORITY=5
6. Tutorial de Threads
6 de 11
MAX_PRIORITY=10
Bien,¿pero que ocurre en el caso de que haya varios hilos listos en el mismo instante con la
misma prioridad?.En est punto debemos hacer la distincion entre hilos nativos e hilos
verdes.En un conjunto de hilos nativos la planificación la realizará el sistema operativo de
acuerdo a su propia Api(por ejemplo en el caso de NT un MLFQ-multilevel feedback queues
de 16+16 grupos divididos en tiempo real y de aplicación) mientras que si se trata de hilos
verdes la planificación la realizará la JVM independientemente de en que sistema se este
ejecutando mediante un Round Robin de tiempo compartido(la teoria de planificación no la
trataremos en este tutorial mas que someramente,se remite al lector a la extensa bibliografía al
respecto).
Por tanto nuestras posibilidades de interactuar en la planificación de los hilos se reduce a
asignarles una prioridad.A est respecto,y entrando en cuestiones de diseño,citaremos el
modelo de Seehein en el que la aplicación está dividida en al menos 3 hilos,uno de logica de
negocio,otro de interfaza de usuario y otro de acceso a datos.En este modelo,debería
concederse a la interfaz de usuaro la más alta prioridad ya que se encontrará la mayor parte
del tiempo inactva esperando una accion por parte del usuario y queremos una respuesta
rapida con el fin de proporcionar sensación de viveza de la aplicación.
En una JVM hay dos tipos de hilos los hilos demonio y los que no lo son.Un demonio es un
proceso(en este caso hilo) diseñado para dar servicio a otros y que se ejecuta en el
background.Podemos determinar o señalar a un hilo como demonio mediante los metodos
boolean isDaemon() y void setDaemon(boolean).Hay que señalar que cuando en la JVM solo
se ejecuten hilos que sean demonios esta se dentendrá y acabará la ejecución del
programa,dado que al ser hilos de servicio y no haber otros hilos a los que prestar ese servicio
se considera que no queda más que hacer.
Señalaremos por último a este respecto el metodo yield()(traducida como ceder el paso).Este
metodo pasa al hilo que lo llama al estado de ejecución a listo,permitiendo que el resto de los
hilos compitan por el uso de CPU.Es importante en hilos de una alta prioridad y que podrían
bloquear el sistema al no dejar al resto de hilos ejecutarse nunca.
Concurrencia y sincronización
La programación concurrente puede dar lugar a muchos errores debido a la utilización de
recursos compartidos que pueden ser alterados.Las secciones de codigo potencialmente
peligrosas de provocar estos errores se conocen como secciones criticas.
En general los programas concurrentes deben ser correctos totalmente.Este concepto es la
suma de dos conceptos distintos la corrección parcial(o safety) esto es que no entrará nunca en
ningún mal estado y la correccion temporal(o liveness) esto es que terminará en un algun
momento de tiempo finito.En estos programas por tanto hay que evitar que varios hilos entren
en una sección critica(exclusión mutua o mutex) y que los programas se
bloqueen(deadlock).Ademas los programas que no terminan nunca(programas reactivos)
deben cumplir la ausencia de inanición(starvation) esto es que tarde o temprano todos los
hilos alcanzen el control del procesador y ninguno quede indefinidamente en la lista de hilos
listos y tambien deben cumplir la propiedad de equitatividad(fairwess) esto es repartir el
tiempo de la forma mas justa entre todos los hilos.
7. Tutorial de Threads
7 de 11
Un monitor impide que varios hilos accedan al mismo recurso compartido a la vez.Cada
monitor incluye un protocolo de entrada y un protocolo de salida.En Java los monitores se
consiguen mediante el uso de la palabra reservada synchronized bien como instrucción de
bloque o bien como modificador de acceso de metodos.Este segundo caso se declararía como
sigue:
public synchronized void metodo()
Este metodo declarado de tal forma garantiza que solo un hilo de esta clase puede acceder a
este metodo a la vez,de tal forma que si un hilo de la misma clase intenta llamar a este metodo
mientras otro hilo esta dentro de el,el hilo que realiza la llamada quedará en estado de
bloqueado esperando a que el primer hilo libere el monitor,esto es,salga del metodo
sincronizado.Sin embargo las seccione criticas,y el uso de mointores define secciones
criticas,es muy costoso en tiempo de ejecucución dado que los demas hilos se detendran hasta
que el monitor sea liberado.Y tambien es costoso en tiempo de computación ya que como
media se ha determinado que un metodo sincronizado se ejecuta 6 veces máslento que uno
que no este sincronizado.Por tanto es recomendable sincronizas sola y exclusivamente
aquellas partes del codigo que formen la sección critica y nada mas.A este fin responde el
delimitador de bloque synchronized,cuyo uso es el siguiente:
synchronized(objeto)
{
...
}
Durante este bloque los el objeto estará sincronizado.
Sin embargo es posible que el uso de monitores de lugar a interbloqueos(situacion en la que
varios hilos no pueden continuar porque estan bloqueados esperando la liberación de un
recurso por parte de otros hilos del mismo grupo de tal manera que ninguno avanza).Para
solucionar este problema se utilizan dos metodos:
wait()
1. Libera el monitor
2. Suspende la ejecución del hilo y van a para a
la cola de espera del monitor(no del
procesador no confundir)
notify()
1. Despierta el hilo y les dice que vuelvan a
mirar la condición que dió lugar al wait.
2. Si esta se sigue cumpliendo entran otra vez
en la cola de espera del monitor y si no es así
se marca como listo(que no en ejecución).
Tambien se puede usar el metodo notifyAll() que notifica a todos los hilos que se encuentren
en espera y no solo al que realiza la llamada.
EJEMPLO:El problema de los lectores-escritores
A continuación diseñaremos una clase que de solución al problema clasico de los lectores-
escritores.En esta situacion tenemos un conjunto de lectores que pueden leer de una fuente
8. Tutorial de Threads
8 de 11
común de forma simultanea,pero nunca deberia haber dos escritores o un escritor y varios
lectores en el mismo instante:
class LectoresEscritores
{
int esperandoEscribir=0;
int nLector=0;
boolean escribieno=false;
public synchronized void obtenerLector()
{
while(escribiendo || esperandoEscribir > 0)
wait();
nLector++;
}
public synchronized void liberarLector()
{
nLector--;
if(nLector == 0) notify();
}
public synchronized void obtenerEscritor()
{
esperandoEscribir++;
while(nLector > 0 || escribiendo)
wait();
escribiendo= true;
esperandoEscribir--;
}
public synchronized void liberarEscritor()
{
escribiendo = false;
notifyAll();
}
}
Un ejemplo para ponerlo todo junto
A continuación desarrollaremos un aplicación que de solución al tambien clasico problema
del productor-consumidor.Este problema consiste en dos hilos uno que produce elementos y
los deposita en un buffer compartido y otro que lee elementos de ese buffer(consume).En todo
momento ha de impedirse que el productor escriba en el buffer sin que el consumidor haya
procesado ese elemento y que el consumidor lea sin que el productor haya puesto nada en el
buffer.
9. Tutorial de Threads
9 de 11
//Clase de testeo
public class Test
{
public static void main(String args[])
{
//Declaramos un buffer
Buffer b = new Buffer();
//Iniciamos el productor y el consumidor
new Thread(new Productor(b)).start();
new Thread(new Consumidor(b)).start();
}
}
//Clase buffer
class Buffer
{
private int n; //El buffer de 1 elemento
private boolean leer = false;
public synchronized void poner(int i)
{
try
{
while(leer)
wait();
}catch(InterruptedException e) { System.out.println(e.getMessage()); }
n=i;
System.out.println("Se pone"+i);
leer=true;
notify();
}
public synchronized int quitar()
{
try
{
while(!leer)
wait();
}catch(InterruptedException e) { System.out.println(e.getMessage()); }
10. Tutorial de Threads
10 de 11
n=i;
System.out.println("Se quita"+n);
leer=false;
notify();
return n;
}
}
//Clase Productor
class Productor implements Runnable
{
Buffer bu;
Productor(Buffer b)
{
bu=b;
}
public void run()
{
int i;
while(true) bu.poner(i);
}
}
//Clase Consumidor
class Consumidor implements Runnable
{
Buffer bu;
Consumidor(Buffer b)
{
bu=b;
}
public void run()
{
int i;
while(true) bu.quitar(i);
}
}
Bibliografía
Titulo:Java Unleashed 1.2
Autor:Jaime Jaworski
Editorial:Prentice Hall
11. Tutorial de Threads
11 de 11
ISBN:84-8322-061-X
Titulo:Mastering Java 2
Autor:Jhon Zukowski
Editorial:Sybex
ISBN:84-415-0948-4
Titulo:Using Java 1.2
Autor:Mike Morgan
Editorial:Prentice Hall
ISBN:0-7897-1627-5
Titulo:Thinking In Java
Autor:Bruce Eckel
Descargable gratuitamente desde www.bruceEckel.com
Tambien se puede consultar mas información en www.javasoft.com.
Para cualquier duda o matización ponerse en contacto con el autor en jmrequena@larural.es.
Editado y distribuido por www.javahispano.com