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.
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 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
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.
El documento describe conceptos relacionados con hilos en Java, incluyendo la definición de un hilo, su ciclo de vida, y técnicas como la interrupción y bloqueo. También cubre el uso de interfaces Runnable y métodos como sleep para gestionar la ejecución concurrente de hilos.
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 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.
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.
1) El documento explica qué son los hilos o threads en .NET y cómo se usan para ejecutar código de forma concurrente. 2) Un ejemplo común es un servidor web, que crea un nuevo hilo para cada solicitud HTTP mientras el hilo principal continúa escuchando nuevas solicitudes. 3) La clase Thread de .NET permite crear e iniciar nuevos hilos, así como controlar su ejecución a través de métodos como Start, Join y Suspend.
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 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
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.
El documento describe conceptos relacionados con hilos en Java, incluyendo la definición de un hilo, su ciclo de vida, y técnicas como la interrupción y bloqueo. También cubre el uso de interfaces Runnable y métodos como sleep para gestionar la ejecución concurrente de hilos.
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 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.
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.
1) El documento explica qué son los hilos o threads en .NET y cómo se usan para ejecutar código de forma concurrente. 2) Un ejemplo común es un servidor web, que crea un nuevo hilo para cada solicitud HTTP mientras el hilo principal continúa escuchando nuevas solicitudes. 3) La clase Thread de .NET permite crear e iniciar nuevos hilos, así como controlar su ejecución a través de métodos como Start, Join y Suspend.
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.
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.
1) Los sistemas operativos modernos tratan las unidades de recursos (procesos) e unidades de despacho (hilos) de forma independiente, donde los procesos son unidades de recursos y los hilos son unidades de despacho.
2) Los procesos son pesados y comparten recursos, mientras que los hilos son livianos, existen varios por proceso, y comparten los recursos del proceso.
3) Los hilos comparten el código, datos y recursos de un proceso, y son baratos de crear y gestionar en comparación con los pro
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.
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 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.
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 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 describe los hilos y su uso en sistemas operativos. Los hilos son mini procesos que comparten el espacio de direcciones con otros hilos de un mismo proceso. Se necesita sincronizar los hilos para evitar interferencias. Los hilos aumentan la eficiencia al permitir cambiar entre tareas de forma más rápida que con procesos completos. Existen varios modelos como servidor-trabajador, equipo y entubamiento.
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.
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.
El documento describe los hilos de ejecución (threads) en Java. Explica que un thread es la ejecución secuencial de instrucciones dentro de un programa, y que Java permite la programación concurrente mediante threads. Detalla los estados de un thread, sus prioridades, y la clase Thread. También explica dos formas de crear e iniciar threads: extendiendo la clase Thread o implementando la interfaz Runnable.
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.
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 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 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.
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 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.
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.
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.
1) Los sistemas operativos modernos tratan las unidades de recursos (procesos) e unidades de despacho (hilos) de forma independiente, donde los procesos son unidades de recursos y los hilos son unidades de despacho.
2) Los procesos son pesados y comparten recursos, mientras que los hilos son livianos, existen varios por proceso, y comparten los recursos del proceso.
3) Los hilos comparten el código, datos y recursos de un proceso, y son baratos de crear y gestionar en comparación con los pro
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.
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 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.
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 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 describe los hilos y su uso en sistemas operativos. Los hilos son mini procesos que comparten el espacio de direcciones con otros hilos de un mismo proceso. Se necesita sincronizar los hilos para evitar interferencias. Los hilos aumentan la eficiencia al permitir cambiar entre tareas de forma más rápida que con procesos completos. Existen varios modelos como servidor-trabajador, equipo y entubamiento.
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.
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.
El documento describe los hilos de ejecución (threads) en Java. Explica que un thread es la ejecución secuencial de instrucciones dentro de un programa, y que Java permite la programación concurrente mediante threads. Detalla los estados de un thread, sus prioridades, y la clase Thread. También explica dos formas de crear e iniciar threads: extendiendo la clase Thread o implementando la interfaz Runnable.
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.
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 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 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.
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 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.
1. TECNOLÓGICO NACIONAL DE MEXICO INSTITUTO
TECNOLÓGICO DE PINOTEPA
ASIGNATURA: TOPICOS AVANZADOS DE PROGRAMACIÓN
TEMA: PROGRAMACION CONCURRENTE
NOMBRE DEL ESTUDIANTE:
DAVID BAUTISTA ALBERTO
CARRERA: ING.SISTEMAS COMPUTACIONALES
DOCENTE: ING. EUGENIA TERESA LOZANO AGUIRRE
SEMESTRE: ENE-JUN 2023
FECHA:27 DE FEBRERO DEL 2023
2. Concepto de hilo.
• Un hilo es un proceso que se está ejecutando en un momento
determinado en nuestro sistema operativo, como cualquier otra tarea,
esto se realiza directamente en el procesador.
• Existen los llamados “demonios” que son los procesos que define el
sistema operativo en sí para poder funcionar y otros que llamaremos los
hilos definidos por el usuario o por el programador, estos últimos son
procesos a los que el programador define un comportamiento e inicia
en un momento específico.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
3. • En .NET, cuando se lanza una aplicación se crea un proceso y dentro de este
proceso un hilo de ejecución o thread para el método main().
• Es posible, a la vez que se ejecuta el método main(), que la aplicación lance
internamente nuevos hilos de ejecución en los que se ejecute el código de
algún método.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
4. • Un ejemplo muy actual de utilización de threads es una aplicación de tipo
servidor Web, como el IIS, Apache Web Server, etc.
• Un servidor Web es una aplicación que, al ser lanzada y creado para ella un
proceso y un hilo para el método main(), espera a que llegue una petición
http de un cliente al puerto que escucha (el 80 generalmente) y cuando
llega hace dos cosas:
• Crea un nuevo hilo de ejecución o thread en el que atiende la petición.
• Vuelve inmediatamente (en el hilo principal) a escuchar el puerto para
atender nuevas peticiones (mientras se atiende la petición en el nuevo
hilo).
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
5. • En equipos con menos procesadores que hilos o threads lanzados en un
momento dado, se habla de concurrencia aparente, ya que todos los hilos no
pueden estar ejecutándose a la vez.
• No obstante, no se ha de pensar que tener un solo procesador hace inútil
lanzar más de un hilo o thread simultáneamente. Ni mucho menos, el 100%
del tiempo de ejecución de un hilo no está ocupado el procesador
(interacción con el usuario, entrada/salida, acceso a memoria), de modo que
otro hilo puede aprovechar sus tiempos muertos.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
6. • También es cierto que un exceso de threads o hilos resulta negativo, ya que
se puede perder más tiempo “saltando” de un thread a otro que en la
ejecución real (a esta operación se la llama “conmutación de contexto” e
implica salvar y recuperar datos y registros de memoria).
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
7. • En Windows, aunque sólo se disponga de un procesador, se permite
ejecutar varios hilos simultáneamente (concurrencia aparente). Lo que se
hace es ofrecer un tiempo determinado de ejecución (time slice o “rodaja
de tiempo”) a cada hilo (realmente son milisegundos). Cuando ese tiempo
finaliza, Windows retoma el control y se lo cede a otro thread.
• De este modo se ofrece al usuario la ilusión de tener varias aplicaciones en
ejecución simultáneamente y también se optimiza el uso de los recursos. A
este modo de organizar la ejecución de varios threads se le llama
preemptive multitasking (“multitarea preemptiva”).
• En realidad, el sistema operativo y cualquier hilo que se lance ya son dos
hilos, con lo cual la ejecución en Windows es siempre multihilo.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
8. La clase Thread.
• Esta clase pertenece al namespace System.Threading. Para crear un thread
sólo hay que crear una instancia de esta clase. Sus métodos más importantes
son:
•start: lanza el thread a ejecución.
•suspend: detiene momentáneamente la ejecución del thread.
•resume: activa el thread suspendido, es decir, lo vuelve a poner en
ejecución.
•abort: aborta o para de modo inmediato la ejecución del thread.
•join: detiene el thread donde se invoca hasta que el thread para el que se
le invoca termina.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
9. • Las propiedades más interesantes de la clase Thread son:
• Name: permite darle un nombre a un thread que lo distinga del
resto.
• CurrentThread: contiene una referencia al thread que está
actualmente en ejecución.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
10. Ejecución de un thread
• Un thread no es más que un bloque de código vacío por defecto que es
posible lanzar a ejecución de modo simultáneo a otros threads.
• Supóngase que se desea crear una aplicación desde la que se lance un
thread que referencie una función que muestre 10 veces un mensaje (“Hola,
soy el thread”) en la consola. La aplicación lanzará también la función desde
el thread principal de la aplicación (main).
• El código necesario para crearlo es el siguiente:
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
12. Detener y activación de un Thread
• Una vez un thread ha sido lanzado puede ser suspendido (suspend),
reactivado (resume) o abortado (abort).
• suspend y resume: suspend suspende la ejecución de un thread
momentáneamente.
• Un thread suspendido puede ser reactivado llamando a resume. Si no se
utilizan bien pueden causar situaciones de bloqueo no recuperables.
• abort: lanza una excepción ThreadAbortException en el thread. El
tratamiento por defecto para esta excepción es finalizar la ejecución del
thread. No obstante si se captura la excepción, se puede programar el
tratamiento que se desee.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
13. Propiedades Name y CurrentThread
• Con la propiedad Name puede darse nombre a ambos threads; y
• La propiedad CurrentThread puede obtenerse el thread principal
para darle nombre.
Propiedad Join
• El método Join pertenece a la clase Thread y lo que hace es detener
la ejecución del thread donde se invoca hasta que el thread para el
que se invoca termina.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
17. Consideraciones
Application.Run(): Esta instrucción ejecuta una forma como aplicación, es
la apropiada para abrir un nuevo hilo.
Cierra la aplicación actual. Se debe tener cuidado al
utilizarla ya que si hay hilos que fueron ejecutados por
esta aplicación se cerrarán también. Lo mejor es usarla
solo en el formulario principal.
Esta instrucción es la más apropiada para cerrar una
forma que fue abierta como hilo ya que solo cierra el
formulario o hilo actual pero no cierra la aplicación.
Application.Exit():
this.close():
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
18. Ejercicio: Abecedario con Hilos
Realice un programa utilizando hilos que haga lo siguiente:
• Debe lanzar 10 hilos que desplieguen el abecedario inglés en minúsculas
(códigos ascii del 65 al 90)
• Cada hilo debe tener un nombre que haga referencia al número de hilo
actual y se debe desplegar cuando se lanza por primera vez, y también junto
a cada letra del abecedario.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
21. Prioridades
• Cuando se lanzan varios threads para que se ejecuten simultáneamente, se
les asignan las “rodajas de tiempo” en función del valor que tenga su
propiedad Priority.
• La propiedad Priority es una propiedad pública de la clase Thread (no es
static). Realmente es una enumeración del tipo ThreadPriority, cuyos
posibles valores son:
TÓPICOS AVANZADOS DE PROGRAMACIÓN
22. Sincronización:
• La sincronización de threads consiste en asegurar que distintos threads
acceden de modo coordinado a recursos compartidos.
• El caso más sencillo es la sincronización del uso del procesador, lo cual se
lleva a cabo por el sistema operativo mediante la “multitarea preemptiva”
(“rodajas de tiempo”).
• Pero existen otras situaciones en las que la sincronización es necesaria y no
la hace por defecto el sistema operativo.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
23. lock
• La sentencia lock bloquea el acceso a un bloque de código,
asegurando que sólo el thread que lo ha bloqueado tiene acceso a tal
bloque.
Supóngase la siguiente clase:
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
26. Clase System.Threading.Monitor
• La clase Monitor implementa el concepto de monitor de
sincronización. Del mismo modo que existe esta clase existen otras
como Mutex, etc.
• la sentencia lock equivale a utilizar un Monitor llamando a sus
métodos Enter (al comienzo del bloque) y Exit (al final del bloque).
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
27. Los métodos más importantes de la clase monitor son:
• Enter: bloquea el segmento de código al que precede.
• TryEnter: es similar a Enter pero no bloquea o produce sólo un bloqueo
temporal.
• Exit: libera el bloque.
• Wait: Detiene al thread que lo llama (muy importante, no bloquea el código
a otros threads sino que detiene al thread llamador) dejándolo en espera de
que otro thread le notifique que puede seguir mediante el método Pulse.
También libera el bloqueo que haya hecho ese thread si es que lo hay.
• Pulse: notifica a un thread en la cola de espera (Wait) que puede continuar.
• PulseAll: realiza la notificación a todos los threads de la cola de espera.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
28. A continuación, como ejemplo, se sustituye en el ejercicio anterior lock por las
correpondientes llamadas a Enter y Exit en la clase Monitor.
int Realizar_Transaccion(int cantidad) {
//comentar este método para ver el problema de no usarlo
Monitor.Enter(this);
{
if (saldo >= cantidad) {
Thread.Sleep(5);
saldo = saldo - cantidad;
System.Console.Write
(Thread.CurrentThread.Name.ToString());
System.Console.WriteLine ("-- Saldo= " +saldo.ToString());
Monitor.Exit(this);
return saldo;
} else
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
29. { // continuacion del Else
//si el balance es menor que la cantidad que se desea retirar
//se deniega la transacción
System.Console.Write
(Thread.CurrentThread.Name.ToString());
System.Console.Write ("-- Transacción denegada.");
System.Console.WriteLine ("-- El saldo sería= " +(saldo - cantidad));
Monitor.Exit(this);
return 0;
}
}
}
Nota: Se puede observar que las llamadas a Exit han de ser antes de return o no se
ejecutarán.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
30. • Clase Mutex (Mutual Exclusion); Su funcionalidad es asegurar que
solamente un hilo pueda tener a acceso a un recurso, o porción de
código, esta clase puede ser usada para evitar que múltiples instancias de
una aplicación sean iniciadas.
• Aparentemente la funcionalidad de la clase Mutex es muy parecida a
Lock, una de las grandes diferencias entre ellas es que Mutex es una clase
y Lock es una Instrucción, la funcionalidad de Mutex es mayor ya que
permite manejar bloqueo a nivel de Sistema Operativo, de tal forma que
actúa a nivel de proceso.
• Cuando un Hilo adquiere una exclusión mutua (mutex), el siguiente Hilo
que intenta adquirir dicha exclusión mutua se suspende hasta que el
primer subproceso libera la exclusión mutua.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
31. • Existen dos tipo de exclusiones mutuas: exclusiones mutuas locales y
exclusiones mutuas del sistema con nombre.
• Si crea un objeto Mutex con un constructor que acepta un nombre, se
asocia a un objeto del sistema operativo con dicho nombre. Las
exclusiones mutuas del sistema con nombre son visibles en todo el
sistema operativo y se pueden utilizar para sincronizar las actividades de
los procesos.
• Con respecto al desempeño de la utilización de Mutex Vs Lock, La
instrucción Lock es mucho mas rápida que la utilización de la clase Mutex.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
32. • Para utilizar la clase Mutex , se requiere el método WaitOne el cual
obtiene el bloqueo exclusivo de un contenido a bloquear. Dicho
bloque es liberado con el método ReleaseMutex. De la misma forma
que se bloqueo con Lock , la clase Mutex puede ser liberada
únicamente con la terminación del hilo que la llamo.
private static Mutex mut = new Mutex();
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
33. • Ejemplo
private static Mutex mut = new Mutex();
public void Sumar() {
mut.WaitOne();
Console.WriteLine("{0} Ingresando de Codigo Protegido",
Thread.CurrentThread.Name);
resultado = operador1 + operador2;
//Bloqueamos el Hilo actual durante un segundo
Thread.Sleep(1000);
Console.WriteLine("El resultado de la Suma es:" + resultado);
Console.WriteLine("{0} Saliendo de Codigo
Protegidon",Thread.CurrentThread.Name);
mut.ReleaseMutex();
}
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
34. Problema de los filósofos comensales:
• Hay cinco filósofos sentados alrededor de una mesa que pasan su vida
cenando y pensando. Cada uno dispone de un plato de arroz y un
palillo a la izquierda de su plato, pero para comer son necesarios dos
palillos y cada filósofo sólo puede sujetar el que está a su izquierda o
el que hay a su derecha. Con un solo palillo en la mano no tienen más
remedio que esperar hasta que atrapen otro y puedan seguir
comiendo.
• Si dos filósofos adyacentes intentan tomar el mismo palillo a la vez se
produce una condición de carrera: ambos compiten por lo mismo
pero uno se queda sin comer.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
35. • Si todos los filósofos cogen el palillo de su derecha al mismo tiempo,
todos se quedarán esperando eternamente porque alguien debe
liberar el palillo que les falta, cosa que nadie hará porque todos se
encuentran en la misma situación (esperando que alguno deje su
palillo). Llegado esto, los filósofos se morirán de hambre. A este
bloqueo mutuo se le denomina interbloqueo o deadlock.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
36. El objetivo consiste en encontrar un recurso que permita que los filósofos
nunca se mueran de hambre. Porque:
• Dos filósofos contiguos no pueden comer a la vez (exclusión mutua).
• Si un filósofo está comiendo, los contiguos no pueden hacerlo hasta
que él termine (sincronización).
• El filósofo que termina de comer debe ceder los palillos para su
posterior utilización (interbloqueo).
TÓPICOS AVANZADOS DE
PROGRAMACIÓN
37. Bibliografía
• Patrick LeBlanc. 2015. Microsoft Visual C# 2013 Step by Step. EE. UU. Octal
Publishing, Inc. ISBN: 978-0-7356-8183-5.
TÓPICOS AVANZADOS DE
PROGRAMACIÓN