Hilos (Threads)

HILOS (THREADS)
INDICE
HILO DE EJECUCIN ........................................................................................................................ 3 DIFERENCIAS ENTRE HILOS Y PROCESOS ................................................................................ 4 FUNCIONALIDAD DE LOS HILOS ................................................................................................... 4 ESTADOS DE UN HILO ..................................................................................................................... 4 VENTAJAS DE LOS HILOS CONTRA PROCESOS....................................................................... 4 SINCRONIZACIN DE HILOS .......................................................................................................... 5 HILOS A NIVEL DE USUARIO (ULT)........................................................................................................... 5 HILOS A NIVEL DE NCLEO (KLT) ............................................................................................................ 6 TAREAS E HILOS. UNIDAD MNIMA DE ASIGNACIN: TAREA. UNIDAD MNIMA DE EXPEDICIN: HILO.................................................................................................................................. 6 CONCEPTOS BSICOS SOBRE HILOS ......................................................................................... 7 CLASES RELACIONADAS CON LOS HILOS ................................................................................ 8 THREAD .................................................................................................................................................... 8 RUNNABLE................................................................................................................................................ 8 THREADDEATH......................................................................................................................................... 9 THREADGROUP........................................................................................................................................ 9 OBJECT .................................................................................................................................................... 9 CREACIN DE HILOS ..................................................................................................................... 10 ESTADO Y CONTROL DE HILOS .................................................................................................. 12 ESTADOS DE UN HILO ............................................................................................................................ 12 New ................................................................................................................................................... 12 Runnable .......................................................................................................................................... 12 Not running....................................................................................................................................... 13 Dead.................................................................................................................................................. 13 CONTROL DE UN HILO ................................................................................................................... 14 ARRANQUE DE UN HILO .......................................................................................................................... 14 MANIPULACIN DE UN HILO ................................................................................................................... 14 SUSPENSIN DE UN HILO ...................................................................................................................... 14 PARADA DE UN HILO .............................................................................................................................. 15 AGRUPAMIENTO DE HILOS ..................................................................................................................... 15 EL GRUPO DE HILOS POR DEFECTO ....................................................................................................... 15 LA CLASE THREADGROUP ........................................................................................................... 16 PLANIFICACIN Y PRIORIDAD DE HILOS .................................................................................. 19 PLANIFICACIN (SCHEDULING).............................................................................................................. 19 PRIORIDAD ............................................................................................................................................. 20 TIEMPO COMPARTIDO ............................................................................................................................ 22 SINCRONIZACIN ........................................................................................................................... 24 MONITORES ..................................................................................................................................... 24 HILOS DEMONIO (DAEMON) ......................................................................................................... 26
USP-Ingeniera Informtica y Sistemas Pgina 1
HILOS (THREADS)
CONCLUSIONES .............................................................................................................................. 26 FUNCIONES MIEMBRO DE LA CLASE THREAD ....................................................................... 26 SUMARIO DE CONSTRUCTORES ............................................................................................................. 27 SUMARIO DE MTODOS .......................................................................................................................... 27 HILOS Y MTODOS NATIVOS ....................................................................................................... 29 HILOS Y LA JNI ................................................................................................................................ 30 HILOS EN APPLETS. EJEMPLOS ................................................................................................. 31 HILOS EN SERVLETS. .................................................................................................................... 32 ORGANIZACIN DE LOS HILOS DE UN PROCESO. .................................................................. 32 MODELO SERVIDOR/TRABAJADOR: ........................................................................................................ 32 MODELO DE COLA DE TRABAJO: ............................................................................................................ 33 MODELO DE EQUIPO: ............................................................................................................................. 33 DISEO DE UN PAQUETE DE HILOS ........................................................................................................ 34 ESTRUCTURA BSICA. .................................................................................................................. 34 PAQUETE DE HILOS DE NIVEL USUARIO. ................................................................................................ 35 PAQUETE DE HILOS DE NIVEL KERNEL. .................................................................................................. 35 VENTAJAS DE LOS HILOS ............................................................................................................... 36 PROBLEMAS POTENCIALES DE LOS HILOS .............................................................................. 38 IMPLEMENTACIN DE BARRERAS. ............................................................................................ 39 Computacin multihilo. ................................................................................................................... 39 MODELO DE COMPUTACIN MULTIHILO. ................................................................................. 39 PROCESOS LIGEROS HILOS O HEBRAS ................................................................................... 40 CARACTERISTICAS ........................................................................................................................ 41
USP-Ingeniera Informtica y Sistemas
Pgina 2
HILOS (THREADS)
Hilo de ejecucin
En sistemas operativos, un hilo de ejecucin, hebra o subproceso es la unidad de procesamiento ms pequea que puede ser planificada por un sistema operativo. La creacin de un nuevo hilo es una caracterstica que permite a una aplicacin realizar varias tareas a la vez (concurrentemente). Los distintos hilos de ejecucin comparten una serie de recursos tales como el espacio de memoria, los archivos abiertos, situacin de autenticacin, etc. Esta tcnica permite simplificar el diseo de una aplicacin que debe llevar a cabo distintas funciones simultneamente. Un hilo es simplemente una tarea que puede ser ejecutada al mismo tiempo con otra tarea. Los hilos de ejecucin que comparten los mismos recursos, sumados a estos recursos, son en conjunto conocidos como un proceso. El hecho de que los hilos de ejecucin de un mismo proceso compartan los recursos hace que cualquiera de estos hilos pueda modificar stos. Cuando un hilo modifica un dato en la memoria, los otros hilos acceden a ese dato modificado inmediatamente. Lo que es propio de cada hilo es el contador de programa, la pila de ejecucin y el estado de la CPU (incluyendo el valor de losregistros). El proceso sigue en ejecucin mientras al menos uno de sus hilos de ejecucin siga activo. Cuando el proceso finaliza, todos sus hilos de ejecucin tambin han terminado. Asimismo en el momento en el que todos los hilos de ejecucin finalizan, el proceso no existe ms y todos sus recursos son liberados. Algunos lenguajes de programacin tienen caractersticas de diseo expresamente creadas para permitir a los programadores lidiar con hilos de ejecucin (como Java o Delphi). Otros (la mayora) desconocen la existencia de hilos de ejecucin y stos deben ser creados mediante llamadas de biblioteca especiales que dependen del sistema operativo en el que estos lenguajes estn siendo utilizados (como es el caso del C y del C++). Un ejemplo de la utilizacin de hilos es tener un hilo atento a la interfaz grfica (iconos, botones, ventanas), mientras otro hilo hace una larga operacin internamente. De esta manera el programa responde de manera ms gil a la interaccin con el usuario. Tambin pueden ser utilizados por una aplicacin servidora para dar servicio a mltiples clientes.
Pgina 3
HILOS (THREADS)
Diferencias entre hilos y procesos

Los hilos se distinguen de los tradicionales procesos en que los procesos son generalmente independientes, llevan bastante informacin de estados, e interactan slo a travs de mecanismos de comunicacin dados por el sistema. Por otra parte, muchos hilos generalmente comparten otros recursos de forma directa. En muchos de los sistemas operativos que dan facilidades a los hilos, es ms rpido cambiar de un hilo a otro dentro del mismo proceso, que cambiar de un proceso a otro. Este fenmeno se debe a que los hilos comparten datos y espacios de direcciones, mientras que los procesos, al ser independientes, no lo hacen. Al cambiar de un proceso a otro el sistema operativo (mediante el dispatcher) genera lo que se conoce como overhead, que es tiempo desperdiciado por el procesador para realizar un cambio de contexto (context switch), en este caso pasar del estado de ejecucin (running) al estado de espera (waiting) y colocar el nuevo proceso en ejecucin. En los hilos, como pertenecen a un mismo proceso, al realizar un cambio de hilo el tiempo perdido es casi despreciable. Sistemas operativos como Windows NT, OS/2 y Linux (2.5 o superiores) dicen tener hilos "baratos", y procesos "costosos" mientras que en otros sistemas no hay una gran diferencia.
Funcionalidad de los hilos

Al igual que los procesos, los hilos poseen un estado de ejecucin y pueden sincronizarse entre ellos para evitar problemas de compartimiento de recursos. Generalmente, cada hilo tiene una tarea especifica y determinada, como forma de aumentar la eficiencia del uso del procesador.
Estados de un hilo
Los principales estados de los hilos son: Ejecucin, Listo y Bloqueado. No tiene sentido asociar estados de suspensin de hilos ya que es un concepto de proceso. En todo caso, si un proceso est expulsado de la memoria principal (RAM), todos sus hilos debern estarlo ya que todos comparten el espacio de direcciones del proceso.
Ventajas de los hilos contra procesos

Si bien los hilos son generados a partir de la creacin de un proceso, podemos decir que un proceso es un hilo de ejecucin, conocido como Monohilo. Pero las ventajas de los hilos se dan cuando hablamos de Multihilos, que es cuando un proceso tiene mltiples hilos de ejecucin los cuales realizan actividades distintas, que pueden o no ser cooperativas entre s. Los beneficios de los hilos se derivan de las implicaciones de rendimiento. 1. Se tarda mucho menos tiempo en crear un hilo nuevo en un proceso existente que en crear un proceso. Algunas investigaciones llevan al resultado que esto es as en un factor de 10.
HILOS (THREADS)
2. Se tarda mucho menos en terminar un hilo que un proceso, ya que cuando se elimina un proceso se debe eliminar el BCP1 del mismo, mientras que un hilo se elimina su contexto y pila. 3. Se tarda mucho menos tiempo en cambiar entre dos hilos de un mismo proceso 4. Los hilos aumentan la eficiencia de la comunicacin entre programas en ejecucin. En la mayora de los sistemas en la comunicacin entre procesos debe intervenir el ncleo para ofrecer proteccin de los recursos y realizar la comunicacin misma. En cambio, entre hilos pueden comunicarse entre s sin la invocacin al ncleo. Por lo tanto, si hay una aplicacin que debe implementarse como un conjunto de unidades de ejecucin relacionadas, es ms eficiente hacerlo con una coleccin de hilos que con una coleccin de procesos separados.
Sincronizacin de hilos
Todos los hilos comparten el mismo espacio de direcciones y otros recursos como pueden ser archivos abiertos. Cualquier modificacin de un recurso desde un hilo afecta al entorno del resto de los hilos del mismo proceso. Por lo tanto, es necesario sincronizar la actividad de los distintos hilos para que no interfieran unos con otros o corrompan estructuras de datos. Una ventaja de la programacin multihilo es que los programas operan con mayor velocidad en sistemas de computadores con mltiples CPUs (sistemas multiprocesador o a travs de grupo de mquinas) ya que los hilos del programa se prestan verdaderamente para la ejecucin concurrente. En tal caso el programador necesita ser cuidadoso para evitar condiciones de carrera (problema que sucede cuando diferentes hilos o procesos alteran datos que otros tambin estn usando), y otros comportamientos no intuitivos. Los hilos generalmente requieren reunirse para procesar los datos en el orden correcto. Es posible que los hilos requieran de operaciones atmicas para impedir que los datos comunes sean cambiados o ledos mientras estn siendo modificados, para lo que usualmente se utilizan los semforos. El descuido de esto puede generar interbloqueo.
Hilos a nivel de usuario (ULT)

En una aplicacin ULT pura, todo el trabajo de gestin de hilos lo realiza la aplicacin y el ncleo o kernel no es consciente de la existencia de hilos. Es posible programar una aplicacin como multihilo mediante una biblioteca de hilos. La misma contiene el cdigo para crear y destruir hilos, intercambiar mensajes y datos entre hilos, para planificar la ejecucin de hilos y para salvar y restaurar el contexto de los hilos. Todas las operaciones descritas se llevan a cabo en el espacio de usuario de un mismo proceso. El kernel continua planificando el proceso como una unidad y asignndole un nico estado (Listo, bloqueado, etc.).
Pgina 5
HILOS (THREADS)
Hilos a nivel de ncleo (KLT)

En una aplicacin KLT pura, todo el trabajo de gestin de hilos lo realiza el kernel. En el rea de la aplicacin no hay cdigo de gestin de hilos, nicamente un API (interfaz de programas de aplicacin) para la gestin de hilos en el ncleo. Windows 2000, Linux y OS/2utilizan este mtodo. Linux utiliza un mtodo muy particular en el que no hace diferencia entre procesos e hilos. Para Linux, si varios procesos creados con la llamada al sistema "clone" comparten el mismo espacio de direcciones virtuales, el sistema operativo los trata como hilos, y lgicamente son manejados por el kernel.
Tareas e hilos.
Unidad mnima de asignacin: tarea. Unidad mnima de expedicin: hilo. Dos hilos de una misma tarea (denominados hilos pares) comparten el segmento de cdigo, el segmento de datos y un espacio de pila, es decir, los recursos asignados a la tarea. Podemos captar la funcionalidad de los hilos si comparamos el control de mltiples hilos con el control de mltiples procesos. En el caso de los procesos, cada uno opera independientemente de los otros; cada proceso tiene su propio contador de programa, registro de pila, y espacio de direcciones. Este tipo de organizacin es muy til cuando los trabajos que los procesos efectan no tienen ninguna relacin entre si. Pero cuando los trabajos a realizar van a necesitar, por ejemplo, la llamada a una misma funcin o bien, la comparticin de una variable en memoria, nos interesar englobarlos en una tarea. Ej: Avion-Torre. Cuando un hilo est en ejecucin, posee el acceso a todos los recursos que tiene asignados la tarea.
Un hilo tendr lo siguiente:

Estado. Contexto del procesador. Punto en el que estamos ejecutando, la instruccin concretamente en la que nos hallamos. Es til a la hora de reanudar un hilo que fue interrumpido con anterioridad, puesto que al guardar el contexto, guardamos la ultima instruccin que ejecutamos, y as podemos conocer por donde tenemos que continuar la ejecucin del hilo.
Pila de ejecucin donde se ir metiendo y sacando instrucciones. (Lugar donde almacenaremos las instrucciones que van a ser ejecutadas). Espacio de almacenamiento esttico donde almacenar las variables. Acceso a los recursos de la tarea, que son compartidos por todos los hilos de la tarea.
Pgina 6
HILOS (THREADS)
Ventajas del uso de hilos.
Se tarda menos tiempo en crear un hilo de una tarea existente que en crear un nuevo proceso. Se tarda menos tiempo en terminar un hilo que en terminar un proceso. Se tarda menos tiempo en cambiar entre dos hilos de una misma tarea que en cambiar entre dos procesos (porque los recursos no cambian, por ejemplo) Es mas sencillo la comunicacin (paso de mensajes por ejemplo) entre hilos de una misma tarea que entre diferentes procesos. Cuando se cambia de un proceso a otro, tiene que intervenir el ncleo del sistema operativo para que haya proteccin. Cuando se cambia de un hilo a otro, puesto que la asignacin de recursos es la misma, no hace falta que intervenga el sistema operativo.
Conceptos Bsicos sobre Hilos

El multihilo soportado en Java gira alrededor del concepto de hilo. La cuestin es, qu es un hilo? De forma sencilla, un hilo es un nico flujo de ejecucin dentro de un proceso. Pero ser mejor comenzar desde el principio y explicar qu es un proceso. Un proceso es un programa ejecutndose dentro de su propio espacio de direcciones. Java es un sistema multiproceso, esto significa que soporta varios procesos corriendo a la vez dentro de sus propios espacios de direcciones. Estamos ms familiarizados con el trmino multitarea, el cual describe un escenario muy similar al multiproceso. Por ejemplo, consideremos la cantidad de aplicaciones que corren a la vez dentro de un mismo entorno grfico. Mientras escribo esto, est corriendo Microsoft Word adems de Internet Explorer, Windows Explorer, CD Player y el Volumen Control. Estas aplicaciones son todas procesos ejecutados dentro de Windows 95. De esta forma, se puede pensar que los procesos son anlogos a las aplicaciones o a programas aislados, pero cada proceso tiene asignado espacio propio de ejecucin dentro del sistema. Un hilo es una secuencia de cdigo en ejecucin dentro del contexto de un proceso. Los hilos no pueden ejecutarse ellos solos; requieren la supervisin de un proceso padre para correr. Dentro de cada proceso hay varios hilos ejecutndose. Por ejemplo, Word puede tener un hilo en background chequeando automticamente la gramtica de lo que estoy escribiendo, mientras otro hilo puede estar salvando automticamente los cambios del documento en el que estoy trabajando. Como Word, cada aplicacin (proceso) puede correr varios hilos los cuales estn realizando diferentes tareas. Esto significa que los hilos estn siempre asociados con un proceso en particular. Los hilos a menudo son conocidos o llamados procesos ligeros. Un hilo, en efecto, es muy similar a un proceso pero con la diferencia de que un hilo siempre corre dentro del contexto de otro programa. Por el contrario, los procesos mantienen su propio espacio de direcciones y entorno de operaciones. Los hilos dependen de un programa padre
HILOS (THREADS)
en lo que se refiere a recursos de ejecucin. La siguiente figura muestra le relacin entre hilos y procesos
Clases Relacionadas con los Hilos

El lenguaje de programacin Java proporciona soporte para hilos a travs de una simple interfaz y un conjunto de clases. La interfaz de Java y las clases que incluyen funcionalidades sobre hilos son las siguientes: Thread Runnable ThreadDeath ThreadGroup Object Todas estas clases son parte del paquete Java.lang.
Thread
La clase Thread es la clase responsable de producir hilos funcionales para otras clases. Para aadir la funcionalidad de hilo a una clase simplemente se deriva la clase de Thread y se ignora el mtodo run. Es en este mtodo run donde el procesamiento de un hilo toma lugar, y a menudo se refieren a l como el cuerpo del hilo. La clase Thread tambin define los mtodos start y stop, los cuales te permiten comenzar y parar la ejecucin del hilo, adems de un gran nmero de mtodos tiles. Al final de este documento, en Apndice A: Funciones Miembro de la Clase Thread (se ha incluido una relacin de mtodos de esta clase con una breve descripcin. Para una documentacin ms extensa de todas las funciones miembro, se sugiere consultar
Runnable
Java no soporta herencia mltiple de forma directa, es decir, no se puede derivar una clase de varias clases padre. Esto nos plantea la duda sobre cmo podemos aadir la funcionalidad de Hilo a una clase que deriva de otra clase, siendo sta distinta de Thread. Para lograr esto se utiliza la interfaz Runnable. La interfaz Runnable proporciona la capacidad de aadir la funcionalidad de un hilo a una clase simplemente implementando la interfaz, en lugar de derivndola de la clase Thread. Gonzlez et al. Las clases que implementan la interfaz Runnable proporcionan un mtodo run que es ejecutado por un objeto hilo asociado que es creado aparte. Esta es una herramienta muy til y a menudo es la nica salida que tenemos para incorporar multihilo dentro de las clases. Esta cuestin ser tratada ms ampliamente en el apartado de Creacin de hilos.Aunque es un nico mtodo el que se define en esta interfaz,
Pgina 8
HILOS (THREADS)
ThreadDeath
La clase de error ThreadDeath proporciona un mecanismo que permite hacer limpieza despus de que un hilo haya sido finalizado de forma asncrona. Se llama a ThreadDeath una clase error porque deriva de la clase Error, la cual proporciona medios para manejar y notificar errores. Cuando el mtodo stop de un hilo es invocado, una instancia de ThreadDeath es lanzada por el moribundo hilo como un error. Slo se debe recoger el objeto ThreadDeath si se necesita para realiza una limpieza especfica a la terminacin asncrona , lo cual es una situacin bastante inusual. Si se recoge el objeto, debe ser relanzado para que el hilo realmente muera
ThreadGroup
La clase ThreadGroup se utiliza para manejar un grupo de hilos de modo conjunto. Esto nos proporciona un medio para controlar de modo eficiente la ejecucin de una serie de hilos. Por ejemplo la clase ThreadGroup nos proporciona mtodos stop, suspend y resume para controlar la ejecucin de todos los hilos pertenecientes al grupo. Los grupos de hilos tambin pueden contener otros grupos de hilos permitiendo una jerarqua anidada de hilos. Los hilos individuales tienen acceso al grupo pero no al padre del grupo.
Object
Aunque, estrictamente hablando, no es una clase de apoyo a los hilos, la clase objeto proporciona unos cuantos mtodos cruciales dentro de la arquitectura multihilo de Java. Estos mtodos son wait, notify y notifyAll. El mtodo wait hace que el hilo de ejecucin espere en estado dormido hasta que se le notifique que contine. Del mismo modo, el mtodo notify informa a un hilo en espera de que contine con su ejecucin. El mtodo notifyAlles similar a notify excepto que se aplica a todos los hilos en espera. Estos tres mtodos solo pueden ser llamados desde un mtodo o bloque sincronizado (o bloque de sincronizacin). Java Threads (Hilos en Java) Normalmente estos mtodos se utilizan cuando hay ejecucin multihilo, es decir, cuando un mtodo espera a que otro mtodo termine de hacer algo antes de poder continuar. El primer hilo espera hasta que otro hilo le notifique que puede continuar. La clase objeto est en la parte superior de la jerarqua de Java, lo cual significa que es el padre de todas las clases. En otras palabras, cada clase Java hereda la funcionalidad proporcionada por la clase objeto, incluyendo los mtodos wait, notify y notifyAll.
Pgina 9
HILOS (THREADS)
Creacin de Hilos
En Java, los hilos comparten el mismo espacio de memoria. Incluso comparten gran parte del entorno de ejecucin, de modo que la creacin de nuevos hilos es mucho ms rpida que la creacin de nuevos procesos. La ventaja que proporcionan los hilos es la capacidad de tener ms de un camino de ejecucin en un mismo programa. As, con un nico proceso, ejecutndose una JVM (Java Virtual Machine), habr siempre ms de un hilo, cada uno con su propio camino de ejecucin. En cuanto al proceso de creacin de hilos, son dos los mecanismos que nos permiten llevarlo a cabo en Java: implementando la interfaz Runnable, o extendiendo la clase Thread, esto es, creando una subclase de esta clase. Lo ms habitual es crear hilos implementando la interfaz Runnable, dado que las interfaces representan una forma de encapsulamiento del trabajo que una clase debe realizar. As, se utilizan para el diseo de requisitos comunes a todas las clases que se tiene previsto implementar. La interfaz define el trabajo, la funcionalidad que debe cubrirse, mientras que la clase o clases que implementan la interfaz realizan dicho trabajo (cumplen esa funcionalidad). Todas las clases o grupos de clases que implementen una cierta interfaz debern seguir las mismas reglas de funcionamiento. El otro mecanismo de creacin de hilos, como ya hemos dicho, consistira en la creacin previa de una subclase de la clase Thread, la cual podramos instanciar despus.
Por ejemplo:
class MiThread extends Thread { public void run() { . . } } .
se corresponde con la declaracin de un clase, MiThread, que extiende la clase Thread, sobrecargando el mtodo Thread.run heredado con su propia implementacin. Es en el mtodo run donde se implementa el cdigo correspondiente a la accin (la tarea) que el hilo debe desarrollar . El mtodo run no es invocado directa o explcitamente (a menos que no quieras que se ejecute dentro de su propio hilo). En lugar de esto, los hilos se arrancan con el mtodo start, se suspenden con el mtodo suspend, se reanudan con el mtodo resume, y se detienen con el mtodo stop (el cual supone tambin la muerte del hilo y la correspondiente excepcin ThreadDeath), como ya explicaremos en el apartado de Estado y Control de Hilos. Un hilo suspendido puede reanudarse en la instruccin del mtodo run en la que fue suspendido. En el
HILOS (THREADS)
caso de crear un hilo extendiendo la clase Thread, se pueden heredar los mtodos y variables de la clase padre. Si es as, una misma subclase solamente puede extender o derivar una vez de la clase padre Thread. Esta limitacin de Java puede ser superada a travs de la implementacin de Runnable. Veamos el siguiente ejemplo: public class MiThread implements Runnable { Thread t; public void run() { // Ejecucin del thread una vez creado } } En este caso necesitamos crear una instancia de Thread antes de que el sistema pueda ejecutar el proceso como un hilo. Adems, el mtodo abstracto run que est definido en la interfaz Runnable tiene que implementarse en la nueva clase creada. La diferencia entre ambos mtodos de creacin de hilos en Java radica en la flexibilidad con que cuenta el programador, que es mayor en el caso de la utilizacin de la interfaz Runnable. Sobre la base del ejemplo anterior, se podra extender la clase MiThread a continuacin, si fuese necesario. La mayora de las clases creadas que necesiten ejecutarse como un hilo implementarn la interfaz Runnable, ya que as queda cubierta la posibilidad de que sean extendidas por otras clases.Por otro lado, es un error pensar que la interfaz Runnable est realizando alguna tarea mientras un hilo de alguna clase que la implemente se est ejecutando. Es una interfaz, y como tal, slo contiene funciones abstractas (concretamente una nica, run), proporcionando tan solo una idea de diseo, de infraestructura, de la clase Thread, pero ninguna funcionalidad. Su declaracin en Java tiene el siguiente aspecto: package Java.lang; public interfaz Runnable { public abstract void run() ; } Comentados los aspectos ms importantes de la interfaz Runnable, veamos ahora la definicin de la clase Thread, de la cual podemos deducir lo que realmente se est haciendo: public class Thread implements Runnable { . . . public void run() {
Pgina 11
HILOS (THREADS)
if( tarea != null ) tarea.run() ; } ...} Se deduce, por tanto, que la propia clase Thread de Java tambin implementa la interfaz Runnable. Observamos que en el mtodo run de Thread se comprueba si la clase con que se est trabajando en ese momento (tarea), que es la clase que se pretende ejecutar como hilo, es o no nula. En caso de no ser nula, se invoca al mtodo run propio de dicha clase.
Estado y Control de Hilos

Estados de un Hilo
El comportamiento de un hilo depende del estado en que se encuentre, este estado define su modo de operacin actual, por ejemplo, si esta corriendo o no. A continuacin proporcionamos la relacin de estados en los que puede estar un hilo Java. New Runnable Not running Dead
New
Un hilo esta en el estado new la primera vez que se crea y hasta que el mtodo start es llamado. Los hilos en estado new ya han sido inicializados y estn listos para empezar a trabajar, pero an no han sido notificados para que empiecen a realizar su trabajo.
Runnable
Cuando se llama al mtodo start de un hilo nuevo, el mtodo run es invocado y el hilo entra en el estado runnable. Este estado podra llamarse running porque la ejecucin del mtodo run significa que el hilo esta corriendo. Sin embargo, debemos tener en cuenta la prioridad de los hilos. Aunque cada hilo est corriendo desde el punto de vista del usuario, en realidad todos los hilos, excepto el que en estos momentos esta utilizando la CPU, estn en el estado runnable (ejecutables, listos para correr) en cualquier momento dado. Uno puede pensar conceptualmente en el estado runnable como si fuera el estado running, slo tenemos que recordar que todos los hilos tienen que compartir los recursos del sistema.
Pgina 12
HILOS (THREADS)
Not running
El estado not running se aplica a todos los hilos que estn parados por alguna razn. Cuando un hilo est en este estado, est listo para ser usado y es capaz de volver al estado runnable en un momento dado. Los hilos pueden pasar al estado not running a travs de varias vas.A continuacin se citan diferentes eventos que pueden hacer que un hilo est parado de modo temporal. El mtodo suspend ha sido llamado El mtodo sleep ha sido llamado El mtodo wait ha sido llamado El hilo esta bloqueado por I/O Para cada una de estas acciones que implica que el hilo pase al estado not running hay una forma para hacer que el hilo vuelva a correr. A continuacin presentamos la lista de eventos correspondientes que pueden hacer que el hilo pase al estado runnable. Si un hilo est suspendido, la invocacin del mtodo resume Si un hilo est durmiendo, pasarn el nmero de milisegundos que se ha especificado que debe dormir Si un hilo est esperando, la llamada a notify o notifyAll por parte del objeto por el que espera Si un hilo est bloqueado por I/O, la finalizacin de la operacin I/O en cuestin
Dead
Un hilo entra en estado dead cuando ya no es un objeto necesario. Los hilos en estado dead no pueden ser resucitados y ejecutados de nuevo. Un hilo puede entrar en estado dead a travs de dos vas: El mtodo run termina su ejecucin. El mtodo stop es llamado. La primera opcin es el modo natural de que un hilo muera. Uno puede pensar en la muerte de un hilo cuando su mtodo run termina la ejecucin como una muerte por causas naturales. En contraste a esto, est la muerte de un hilo por causa de su mtodo stop. Una llamada al mtodo stop mata al hilo de modo asncrono. Aunque la segunda opcin suene un poco brusca, a menudo es muy til. Por ejemplo, es bastante comn que los applets maten sus hilos utilizando el mtodo stop cuando el propio mtodo stop del applet ha sido invocado. La razn de esto es que el mtodo stop del appletes llamado normalmente como respuesta al hecho de que el usuario ha abandonado la pgina
HILOS (THREADS)
web que contena el applet y no es adecuado dejar hilos de un applet corriendo cuando el appletno est activo, as que es deseable matar los hilos.
Control de un hilo
Arranque de un hilo
En el contexto de las aplicaciones, sabemos que es main la primera funcin que se invoca tras arrancar, y por tanto, lgicamente, es el lugar ms apropiado para crear y arrancar otros hilos. La lnea de cdigo: t1 = new TestTh( "Thread 1",(int)(Math.random()*2000) );siendo TestTh una subclase de la clase Thread (o una clase que implemente la interfaz Runnable) crea un nuevo hilo. Los dos argumentos pasados, sin mayor relevancia, satisfarn el prototipo del constructor de la clase y se utilizarn para la inicializacin del objeto. Al tener control directo sobre los hilos, tenemos que arrancarlos explcitamente. Como ya se coment anteriormente, es la funcin miembro start la que nos permite hacerlo.
En nuestro ejemplo sera:

t1.start(); start, en realidad es un mtodo oculto en el hilo que llama al mtodo run.
Manipulacin de un hilo
Si todo fue bien en la creacin del objeto TestTh (t1), ste debera contener un hilo, una traza de ejecucin vlida, que controlaremos en el mtodo run del objeto. El cuerpo de esta funcin miembro viene a ser el cuerpo de un programa como ya los conocemos. Digamos que es la rutina main a nivel de hilo. Todo lo que queremos que haga el hilo debe estar dentro del mtodo run. Cuando finalice run, finalizar tambin el hilo que lo ejecutaba.
Suspensin de un Hilo
La funcin miembro suspend de la clase Thread permite tener un control sobre el hilo de modo que podamos desactivarlo, detener su actividad durante un intervalo de tiempo indeterminado, a diferencia del uso de la llamada al sistema sleep, que simplemente lleva al hilo a un estado de dormido, y siempre durante un nmero de milisegundos concreto. Este mtodo puede resultar til si, construyendo un applet con un hilo de animacin, queremos permitir al usuario detener (que no finalizar) la animacin, hasta que ste decida reanudarla.Este mtodo no detiene la ejecucin permanentemente. El hilo es suspendido indefinidamente y para volver a activarlo de nuevo necesitamos realizar una invocacin a la funcin miembro resume.
Pgina 14
HILOS (THREADS)
Parada de un Hilo
Ya conocemos los mtodos de control de hilos que nos permiten arrancarlos, suspenderlos y reanudarlos. El ltimo elemento de control que se necesita sobre hilos es el mtodo stop, utilizado para terminar la ejecucin de un hilo de forma permanente: t1.stop(); Sealar que esta llamada no destruye el hilo, sino que detiene su ejecucin, y sta no puede reanudarse con el mtodo start. Cuando se desasignen las variables que se usan en el hilo, el objeto hilo (creado con new) quedar marcado para eliminarlo y el garbage collector(recolector de basura de Java) se encargar de liberar la memoria que utilizaba. Tiene sentido su utilidad, por ejemplo, en aplicaciones complejas que necesiten un control sobre cada uno de los hilos que se lancen. Por ltimo, un mtodo de control de hilos que nos permite comprobar si una instancia est viva (el hilo se ha arrancado y an no se ha detenido) o no (bien no se arranc; bien ya finaliz). Estamos hablando de la funcin miembro isAlive. t1.isAlive(); Devolver true en caso de que el hilo t1 est vivo, es decir, ya se haya llamado a su mtodo run y no haya sido parado con un stop ni haya terminado el mtodo run en su ejecucin. En otro caso, lgicamente, devolver false.
Agrupamiento de Hilos
Todo hilo de Java es un miembro de un grupo de hilos. Los grupos de hilos proporcionan un mecanismo de reunin de mltiples hilos dentro de un nico objeto y de manipulacin de dichos hilos en conjunto, en lugar de una forma individual. Por ejemplo, se pueden arrancar o suspender todos los hilos que estn dentro de un grupo con una nica llamada al mtodo. Los grupos de hilos de Java estn implementados por la clase ThreadGroup en el paquete Java.lang. El runtime system (sistema de tiempo de ejecucin) de Java pone un hilo dentro de un grupo de hilos en el momento de la construccin del mismo. Cuando creas un hilo, se puede dejar que el sistema de tiempo de ejecucin ponga el nuevo hilo en algn grupo razonable por defecto, o se puede establecer explcitamente el grupo del nuevo hilo. El hilo es un miembro permanente de aquel que sea el grupo de hilos al cual se uni en el momento de su creacin. No puede moverse un hilo a un nuevo grupo una vez que ha sido creado.
El grupo de hilos por defecto

Si se crea un nuevo hilo sin especificar su grupo en el constructor, el sistema de tiempo de ejecucin colocar el nuevo hilo automticamente en el mismo grupo que el hilo que lo ha creado (conocido como grupo de hilos actual e hilo actual, respectivamente). As que, cul es el grupo de hilos del hilo principal de una aplicacin? Cuando se arranca una aplicacin Java, el sistema de tiempo de ejecucin de Java crea una instancia de la clase ThreadGroup llamada main. A menos que especifiques lo contrario, todos los nuevos hilos que crees se convertirn en miembros del grupo de hilos main.
Pgina 15
HILOS (THREADS)
Creacin de un hilo en un grupo de forma explcita

Como hemos mencionado anteriormente, un hilo es un miembro permanente de aquel grupo de hilos al cual se uni en el momento de su creacin (no tenemos la posibilidad de cambiarlo posteriormente). De este modo, si quieres poner tu nuevo hilo en un grupo de hilos distinto del grupo por defecto, debes especificarlo explcitamente cuando lo creas. La clase Thread tiene tres constructores que te permiten establecer un nuevo grupo de hilos. public Thread( ThreadGroup group, Runnable runnable ) public Thread( ThreadGroup group, String name ) public Thread( ThreadGroup group, Runnable runnable, String name ) Cada uno de estos constructores crea un nuevo hilo, lo inicializa en base a los parmetros Runnable y String, y hace al nuevo hilo miembro del grupo especificado. Por ejemplo, la siguiente muestra de cdigo crea un grupo de hilos (myThreadGroup) y entonces crea un hilo (myThread) en dicho grupo ThreadGroup myThreadGroup = new ThreadGroup( My Group of Threads ); Thread myThread = new Thread( myThreadGroup, a thread for my group ); El ThreadGroup pasado al constructor Thread no tiene que ser necesariamente un grupo que hayas creado t, puede tratarse de un grupo creado por el sistema de ejecucin de Java, o un grupo creado por la aplicacin en la cual se est ejecutando el applet.
La clase ThreadGroup
La clase ThreadGroup es la implementacin del concepto de grupo de hilos en Java. Ofrece, por tanto, la funcionalidad necesaria para la manipulacin de grupos de hilos para las aplicaciones Java. Un objeto ThreadGroup puede contener cualquier nmero de hilos. Los hilos de un mismo grupo generalmente se relacionan de algn modo, ya sea por quin los cre, por la funcin que llevan a cabo, o por el momento en que deberan arrancarse y parar.
Pgina 16
HILOS (THREADS)
El grupo de hilos de ms alto nivel en una aplicacin Java es el grupo de hilos denominado
main. La clase ThreadGroup tiene mtodos que pueden ser clasificados como sigue: Collection Managment Methods (Mtodos de administracin del grupo): mtodos que manipulan la coleccin de hilos y subgrupos contenidos en el grupo de hilos. Methods That Operate on the Group (Mtodos que operan sobre el grupo): estos mtodos establecen u obtienen atributos del objeto ThreadGroup. Methods That Operate on All Threads within a Group (Mtodos que operan sobre todos los hilos dentro del grupo): este es un conjunto de mtodos que desarrollan algunas operaciones, como inicio y reinicio, sobre todos los hilos y subgrupos dentro del objeto ThreadGroup. Access Restriction Methods (Mtodos de restriccin de acceso): ThreadGroup y Thread permiten al administrador de seguridad restringir el acceso a los hilos en base a la relacin de miembro/grupo con el grupo
Mtodos que operan sobre todos los hilos de un grupo

La clase ThreadGroup tiene tres mtodos que te permiten modificar el estado actual de todos los hilos pertenecientes al grupo: - resume - stop - suspend Estos mtodos suponen el cambio correspondiente de estado para todos y cada uno de los hilos del grupo, as como los de sus subgrupos. No se aplican, por tanto, a un nivel de grupo, sino que se aplican individualmente a todos los miembros.
Mtodos de restriccin de acceso

La clase ThreadGroup no impone ninguna restriccin de acceso por s sola, como permitir a los hilos de un grupo consultar o modificar los hilos de un grupo diferente. En lugar de esto, las clases Thread y ThreadGroup cooperan con los administradores de seguridad (subclases de la clase SecurityManager), la cual impone las restricciones de acceso basndose en la pertenencia de los hilos a los grupos.Ambas clases, Thread y ThreadGroup, tienen un mtodo, checkAccess, la cual invoca al mtodo checkAccess del administrador de seguridad actual. El administrador de seguridad decide si debe permitir el acceso basndose en la relacin de pertenencia entre el grupo y los hilos
Pgina 17
HILOS (THREADS)
implicados. Si no se permite el acceso, le mtodo checkAccess lanza una excepcin de tipo SecurityException. En otro caso, checkAccess simplemente retorna. La siguiente es una lista de mtodos de ThreadGroup que invocan al mtodo checkAccess de la propia clase antes de llevar a cabo la accin del mtodo en cuestin. Estos son los que se conocen como accesos regulados, esto es, accesos que deben ser aprobados por el administrador de seguridad antes de completarse. - ThreadGroup (ThreadGroup parent, String name) - setDameon(boolena isDaemon) - setMaxPriority(int maxPriority) - stop - suspend - resume - destroy Igualmente, los siguientes mtodos de la clase Thread invocan al mtodo checkAccess de la clase antes de completarse la accin que desarrollan: - constructores que especifican un grupo de hilos - stop - supend - resume - setPriority(int priority) - setName(String name) - setDaemon(boolean isDaemon)
Una aplicacin stand-alone de Java no tiene, por defecto, un administrador de seguridad; no se impone ninguna restriccin de acceso y cualquier hilo puede consultar o modificar cualquier otro hilo, sea cual sea el grupo en el que se encuentren. Puedes definir e implementar tus propias restricciones de acceso para los grupos de hilos mediante la creacin de subclases de la clase SecurityManager, rescribiendo los mtodos apropiados, e imponiendo ese SecurityManager como el actual administrador de seguridad de tu aplicacin. El navegador HotJava es un ejemplo de aplicacin que implementa su propio administrador de seguridad. HotJava necesita asegurar que los applets se comportan de forma correcta y que no realizan ninguna accin sucia respecto a los dems applets que se estn ejecutando al mismo tiempo (como por ejemplo rebajar la prioridad de los hilos de otro applet). El administrador de seguridad de HotJava no permite a los hilos pertenecientes a grupos
HILOS (THREADS)
diferentes modificarse entre s. Obsrvese que las restricciones de acceso basadas en los grupos de hilos pueden variar de un navegador a otros, de modo que los applets tal vez se comporten de distinta manera en distintos navegadores. A continuacin, una breve explicacin sobre la seguridad en Java, concretamente en relacin a los applets.
Planificacin y Prioridad de Hilos

Planificacin (Scheduling)
Java tiene un Planificador (Scheduler), una lista de procesos, que muestra por pantalla todos los hilos que se estn ejecutando en todos los programas y decide cules deben ejecutarse y cules deben encontrarse preparados para su ejecucin. Hay dos caractersticas de los hilos que el planificador tiene en cuenta en este proceso de decisin. La prioridad del hilo (la ms importante). El indicador de demonio (que pasaremos a explicar en los siguientes apartados). La regla bsica del planificador es que si solamente hay hilos demonio ejecutndose, la Mquina Virtual Java (JVM) concluir. Los nuevos hilos heredan la prioridad y el indicador de demonio de los hilos que los han creado. El planificador determina qu hilos debern ejecutarse comprobando la prioridad de todos los hilos. Aquellos con prioridad ms alta dispondrn del procesador antes de los que tienen prioridad ms baja. El planificador puede seguir dos patrones, preventivo y no preventivo. Los planificadores preventivos proporcionan un segmento de tiempo a todos los hilos que estn corriendo en el sistema. El planificador decide cul ser el siguiente hilo a ejecutarse y llama a resume para darle vida durante un perodo fijo de tiempo. Cuando finaliza ese perodo de tiempo, se llama a su mtodo suspend y el siguiente hilo en la lista de procesos ser relanzado mediante su mtodo resume. Los planificadores no preventivos, en cambio, deciden qu hilo debe correr y lo ejecutan hasta que concluye. El hilo tiene control total sobre el sistema mientras est en ejecucin. El mtodo yield es un mecanismo que permite a un hilo forzar al planificador para que comience la ejecucin de otro hilo que est esperando. Dependiendo del sistema en que est corriendo Java, el planificador ser preventivo o no preventivo. El planificador de hilos no est especificado tan rigurosamente como el resto de clases en Java, y en este asunto hay, sin duda, diferencias de un sistema a otro. Por ejemplo, la versin del JDK 1.0.2 de Solaris es una versin no preventiva, a diferencia del planificador de Win32, que s lo es. [Esto es exactamente lo opuesto a lo que nos esperbamos.] Un planificador no preventivo no interrumpir un hilo en ejecucin, de forma muy parecida al comportamiento de Windows 3.1. El planificador de hilos Java de Win32 s interrumpir los hilos en ejecucin, dando lugar a una planificacin ms fiable. Por ejemplo, si se arrancan dos hilos con grandes bucles de ejecucin bajo un sistema Solaris, el hilo que arranc antes completar su tarea antes de que el otro consiga arrancar. Pero en Windows95 o NT, el segundo hilo s consigue turno de ejecucin.
Pgina 19
HILOS (THREADS)
Prioridad
Cada hilo tiene una prioridad, que no es ms que un valor entero entre 1 y 10, de modo que cuanto mayor el valor, mayor es la prioridad. El planificador determina el hilo que debe ejecutarse en funcin de la prioridad asignada a cada uno de ellos. Cuando se crea un hilo en Java, ste hereda la prioridad de su padre, el hilo que lo ha creado. A partir de aqu se le puede modificar su prioridad en cualquier momento utilizando el mtodo setPriority . Las prioridades de un hilo varan en un rango de enteros comprendido entre MIN_PRIORITY y MAX_PRIORITY (anbas definidas en la clase Thread). El entero ms alto designar la prioridad ms alta y el ms bajo, como es de esperar, la menor. Se ejecutar primero el hilo de prioridad superior, el llamado Ejecutables, y slo cuando ste para, abandona o se convierte en No Ejecutable, comienza la ejecucin de en hilo de prioridad inferior. Si dos hilos tienen la misma prioridad, el programador elige uno de ellos en alguna forma de competicin. El hilo seleccionado se ejecutar hasta que:
Un hilo comprioridad mayor pase a ser Ejecutable. En sistemas que soportan tiempo-compartido, termina su tiempo. Abandone, o termine su mtodo run. Luego, un segundo hilo puede ejecutarse, y as continuamente hasta que el intrprete abandone. El algoritmo del sistema de ejecucin de hilos que sigue Java es de tipo preventivo. Si en un momento dado un hilo que tiene una prioridad mayor a cualquier otro hilo que se est ejecutando pasa a ser Ejecutable, entonces el sistema elige a este nuevo hilo.
Ejemplo: carrera de hilos

En el siguiente ejemplo, mostramos la ejecucin de dos hilos con diferentes prioridades. Un hilo se ejecuta a prioridad ms baja que el otro. Los hilos incrementarn sus contadores hasta que el hilo que tiene prioridad ms alta alcance al contador que corresponde a la tarea con ejecucin ms lenta. import Java.awt.*; import Java.applet.Applet; // En este applet se crean dos hilos que incrementan un contador, se // proporcionan distintas prioridades a cada uno y se para cuando los // dos coinciden public class SchThread extends Applet {
HILOS (THREADS)
Contar alto,bajo; public void init() { // Creamos un thread en 200, ya adelantado bajo = new Contar( 200 ); // El otro comienza desde cero alto = new Contar( 0 ); // Al que comienza en 200 le asignamos prioridad mnima bajo.setPriority( Thread.MIN_PRIORITY ); // Y al otro mxima alto.setPriority( Thread.MAX_PRIORITY ); System.out.println( "Prioridad alta es "+alto.getPriority() ); System.out.println( "Prioridad baja es "+bajo.getPriority() ); } // Arrancamos los dos threads, y vamos repintando hasta que //el thread que tiene prioridad ms alta alcanza o supera al //que tiene prioridad ms baja, pero empez a contar ms //alto public void start() { bajo.start(); alto.start(); while( alto.getContar() < bajo.getContar() ) repaint(); repaint(); bajo.stop(); alto.stop(); } // Vamos pintando los incrementos que realizan ambos threads
HILOS (THREADS)
public void paint( Graphics g ) { g.drawString( "bajo = "+bajo.getContar()+ " alto = "+alto.getContar(),10,10 ); System.out.println( "bajo = "+bajo.getContar()+ " alto = "+alto.getContar() ); } // Para parar la ejecucin de los threads public void stop() { bajo.stop(); alto.stop(); } }
Tiempo compartido
La estrategia del tiempo compartido determina cul de una serie de hilos con igual prioridad se pasa a ejecutar. Por ejemplo, supongamos un programa Java que crea dos hilos egostas con la misma prioridad, que tienen el siguiente mtodo run: public void run() { while (tick < 400000) { tick++; if ((tick % 50000) == 0) { System.out.println("Thread #" + num + ", tick = " + tick); } } } Este mtodo slo cuenta desde 1 hasta 400.000. La variable tick es pblica y se utiliza para determinar cunto se ha progresado. Cada 50.00 ticks imprime el identificador del hilo y su contador tick. Cuando este programa se ejecuta en un sistema que utiliza el tiempo compartido, la salida ser del tipo : Thread #1, tick = 50000
HILOS (THREADS)
Thread #0, tick = 50000 Thread #0, tick = 100000 Thread #1, tick = 100000 Thread #1, tick = 150000 Thread #1, tick = 200000 Thread #0, tick = 150000 Thread #0, tick = 200000 Thread #1, tick = 250000 Thread #0, tick = 250000 Thread #0, tick = 300000 Thread #1, tick = 300000 Thread #1, tick = 350000 Thread #0, tick = 350000 Thread #0, tick = 400000 Thread #1, tick = 400000 El sistema de tiempo compartido divide el tiempo de proceso de la CPU en espacios de tiempo y le asigna tiempo de proceso a un hilo dependiendo de su prioridad. En este caso, como las prioridades del los hilos eran iguales, los tiempos de proceso tambin lo son. Observa que el tiempo compartido nos ofrece garantas sobre la frecuencia y el orden en el que se van a ejecutar los hilos. Para hacer una comparativa, veamos cmo sera la salida en una mquina sin tiempo compartido, donde se ejecuta un nico hilo continuadamente hasta que aparece otro con prioridad superior. Thread #0, tick = 50000 Thread #0, tick = 100000 Thread #0, tick = 150000 Thread #0, tick = 200000 Thread #0, tick = 250000 Thread #0, tick = 300000 Thread #0, tick = 350000 Thread #0, tick = 400000
Pgina 23
HILOS (THREADS)
Thread #1, tick = 50000 Thread #1, tick = 100000 Thread #1, tick = 150000 Thread #1, tick = 200000 Thread #1, tick = 250000 Thread #1, tick = 300000 Thread #1, tick = 350000 Thread #1, tick = 400000 Nota: No todos los sistemas aceptan el tiempo compartido, por lo tanto los programas en ava no deberan ser relativos al tiempo compartido ya que podran producirse resultados distintos para sistemas diferentes.
Sincronizacin
El problema de la sincronizacin de hilos tiene lugar cuando varios hilos intentan acceder al mismo recurso o dato. A la hora de acceder a datos comunes, los hilos necesitan establecer cierto orden, por ejemplo en el caso del productor consumidor. Para asegurarse de que hilos concurrentes no se estorban y operan correctamente con datos (o recursos) compartidos, un sistema estable previene la inanicin y el punto muerto o interbloqueo. La inanicin tiene lugar cuando uno o ms hilos estn bloqueados al intentar conseguir acceso a un recurso compartido de ocurrencias limitadas. El interbloqueo es la ltima fase de la inanicin; ocurre cuando uno o ms hilos estn esperando una condicin que no puede ser satisfecha. Esto ocurre muy frecuentemente cuando dos o ms hilos estn esperando a que el otro u otros se desbloquee, respectivamente. A continuacin se presenta un ejemplo, el problema del Productor/Consumidor, con la intencin de explicar de una forma ms prctica el concepto y las situciones de sincronizacin de hilos.
Monitores
A los objetos como CubbyHole, a los que acceden varios hilos, son llamados condiciones variables. Una de las formas de controlar el acceso a estas condiciones variables y de, por tanto, sincronizar los hilos, son los monitores. Las secciones crticas son los segmentos del cdigo donde los hilos concurrentes acceden a las condiciones variables. Estas secciones, en Java, se marcan normalmente con la palabra reservada synchronized: Synchronized int MiMetodo(); Generalmente, las secciones crticas en los programas de Java son los mtodos. Sin embargo el uso indiscriminado de synchronized viola los fundamentos de la programacin objetual, por lo que es mejor utilizar synchronized slo a nivel de mtodos. Java asocia un solo monitor a cada objeto que tiene un mtodo sincronizado.
HILOS (THREADS)
En el ejemplo anterior del productorconsumidor tiene dos mtodos de sincronizacin: put(), que cambia el valor de CubbyHole, y get(), para recuperar el valor actual. Este sera el cdigo fuente del objeto CubbyHole utilizando las tcnicas de sincronizacin nuevas : Gonzlez et al. class CubbyHole { private int contents; private boolean available = false; public synchronized int get() { while (available == false) { try { wait(); } catch (InterruptedException e) { } } available = false; notify(); return contents; } public synchronized void put(int value) { while (available == true) { try { wait(); } catch (InterruptedException e) { } } contents = value; available = true; notify(); } }
HILOS (THREADS)
La variable contents tiene el valor actual de CubbyHole y available indica si se puede recuperar o no el valor. Cuando available es verdadero, el productor an no ha acabado de producir. CubbyHole tiene dos mtodos de sincronizacin, y Java proporciona un solo monitor para cada ejemplar de CubbyHole (incluyendo el compartido por el Productor y el Consumidor). Siempre que el control entra en un mtodo sincronizado, el hilo que ha llamado al mtodo adquiere el monitor del objeto al cual pertenece el mtodo. Otros hilos no pueden llamar a un mtodo sincronizado del mismo objeto mientras el monitor no sea liberado. Nota: Java permite re-adquirir un monitor. En este caso se trata de los llamados monitores re-entrantes.
Hilos Demonio (Daemon)

Un proceso demonio es un proceso que debe ejecutarse continuamente en modo background(en segundo plano), y generalmente se disea para responder a peticiones de otros procesos a travs de la red. La palabra daemon (proveniente de la palabra griega ghost) es propia de UNIX, pero no se utiliza de este mismo modo en Windows. En Windows NT, los demonios se denominan servicios. Cuando los servicios atienden peticiones, se conocen como la parte Servidor de una arquitectura Cliente/Servidor. Los hilos demonio tambin se llaman servicios, porque se ejecutan, normalmente, con prioridad baja y proporcionan un servicio bsico a un programa o programas cuando la actividad de la mquina es reducida. Un ejemplo de hilo demonio que est ejecutndose continuamente es el recolector de basura (garbage collector). Este hilo, proporcionado por la Mquina Virtual Java, comprueba las variables de los programas a las que no se accede nunca y libera estos recursos, devolvindolos al sistema. Un hilo puede fijar su indicador de demonio pasando un valor true al mtodo setDaemon(). Si se pasa false a este mtodo, el hilo ser devuelto por el sistema como un hilo de usuario. No obstante, esto ltimo debe realizarse antes de que se arranque el hilo con el mtodo start().
Conclusiones
Se pueden usar hilos Java como standard, sin tener en cuenta la plataforma en la que vayan a ejecurtarse. La clase Thread es la clase responsable de producir hilos funcionales para otras clases. La interfaz Runnable proporciona la capacidad de aadir la funcionalidad de un hilo a una clase en lugar de derivndola de la clase Thread.Para arrancar un hilo se llama a su mtodo start el cual invoca al mtodo run del propio hilo. Todo la tarea del hilo debe estar dentro del mtodo run.Para terminar la ejecucin de un hilo de forma permanente se utiliza su mtodo stop.La clase ThreadGroup es la implementacin del concepto de grupo de hilos en Java. Java tiene un Planificador (Scheduler), el cual decide que hilos deben ejecuatarse y cuales encontrarse preparados para su ejecucin. Cada hilo tiene una prioridad, que no es ms que un valor entero entre 1 y 10, de modo que cuanto mayor el valor, mayor es la prioridad.
Funciones Miembro de la Clase Thread
Pgina 26
HILOS (THREADS)
Sumario de constructores
Thread() Realiza la reserva de memoria necesaria para la creacin de un nuevo objeto Thread. Thread(Runnable target) Realiza la reserva de memoria necesaria para la creacin de un nuevo objeto Thread. Thread(Runnable target, String name) Realiza la reserva de memoria necesaria para la creacin de un nuevo objeto Thread. Thread(String name) Realiza la reserva de memoria necesaria para la creacin de un nuevo objeto Thread. Thread(ThreadGroup group, Runnable target) Realiza la reserva de memoria necesaria para la creacin de un nuevo objeto Thread. Thread(ThreadGroup group, Runnable target, String name) Crea un nuevo objeto Thread con un objeto de ejecucin concreto y un nombre concreto, y se une al grupo de hilos especificado. Thread(ThreadGroup group, String name) Crea un nuevo objeto Thread como miembro de un grupo de hilos concreto.
Sumario de mtodos
No se citan todos los mtodos. Para amplicacin del sumario, se sugiere consultar la pgina static int activeCount() Devuelve el nmero actual de hilos activos en el grupo de hilos de este hilo. void checkAccess() Determina si el hilo actualmente en ejecucin tiene permiso para modificar este hilo. static Thread currentThread() Devuelve una referencia al objeto hilo que se est ejecutando actualmente void destroy() Destruye este hilo, sin realizar ningn tipo de limpieza static void dumpStack() Imprime una traza de pila del hilo actual
HILOS (THREADS)
static int enumerate(Thread[] tarray) Copia dentro del array especificado todos los hilos activos del grupo y subgrupos de hilos del hilo en cuestin ClassLoader getContextClassLoader() Devuelve el contexto ClassLoader de este Thread String getName() Devuelve el nombre del hilo void setName(String name) Cambia el nombre de este hilo, asignndole el especificado como argumento int getPriority() Devuelve la prioridad del hilo ThreadGroup getThreadGroup() Devuelve el grupo de hilos al cual cual pertenece el hilo void interrupt() Interrumpe la ejecucin del hilo static boolean interrupted() Comprueba si el hilo actual ha sido interrumpido boolean isAlive() Comprueba si el hilo est vivo boolean isDaemon() Comprueba si el hilo es un hilo daemon void setDaemon(boolean on) Establece este hilo como hilo daemon, o como hilo de usuario void join() Espera a que este hilo muera void join(long millis) Espera, como mucha millis milisegundos a que este hilo muera void run() Si este hilo se construy utilizando un objeto Runnable de ejecucin independiente,
HILOS (THREADS)
entonces el mtodo run de ese objeto es invocado; en otro caso, este mtodo no hace nada y vuelve. static void sleep(long millis) Hace que el hilo actualmente en ejecucin pase a dormir temporalmente durante el nmero de milisegundos especificado. void start() Hace que este hilo comience la ejecucin; la Mquina Virtual de Java llama al mtodo runde este hilo. String toString() Devuelve una representacin en formato cadena de este hilo, incluyendo el nombre del hilo, la prioridad, y el grupo de hilos. static void yield() Hace que el hilo actual de ejecucin, pare temporalmente y permita que otros hilos se ejecuten (til en sistemas con planificacin de hilos no preventiva). Se aconseja consultar las referencia citada anteriormente para consultar la descripcin de mtodos cuyo uso directo es inherentemente inseguro, como son stop, suspend y resume
Hilos y Mtodos Nativos

Un mtodo nativo no es ms que un programa o funcin escrita en un lenguaje de programacin distinto a Java. Partiendo de las dos mximas de Java (portabilidad y reutilizacin), Java permite la integracin de mtodos nativos en sus aplicaciones, aunque esto suponga una limitacin a la portabilidad del nuevo software. La Interfaz de Java Nativo (JNI) se define como el vnculo entre la aplicacin de Java y el cdigo nativo, permitiendo el acceso a mtodos nativos a travs de bibliotecas compartidas de vnculos dinmicos (en Windows, las conocidas DLL). Podremos, de este modo, invocar desde una aplicacin Java un mtodo nativo del mismo modo que se hace si se est en una aplicacin nativa. As, le pasaremos los argumentos apropiados y recogeremos el valor de retorno si as procede. La JNI proporciona la posibilidad, tambin de incluir la JVM en aplicaciones que no sean de Java. Por otro lado, la plataforma Java es un sistema multihilo. Debido a esto, los mtodos nativos deben ser programas seguros respecto a la ejecucin en multihilo. A menos que tengas conocimiento de lo contrario, como, por ejemplo, saber que el mtodo nativo est sincronizado, debes asumir o tener en cuenta que en cualquier instante de tiempo puede haber mltiples hilos de control ejecutando el mtodo nativo. Los mtodos nativos, por tanto, no deben modificar variables globales sensibles de forma desprotegida. Esto es, deben compartir y coordinar su acceso a variables en determinadas secciones crticas de cdigo.
Pgina 29
HILOS (THREADS)
Conviene estar familiarizado con los conceptos bsicos sobre hilos, en general, y ms concretamente en Java, as como con la programacin multihilo, para poder entrar en la programacin multihilo y con mtodos nativos.
Hilos y la JNI
A continuacin se presenta una serie de precauciones que deben tenerse en cuenta a la hora de programar en multihilo con mtodos nativos: El puntero a la interfaz JNI (JNIEnv *) slo es vlido en el hilo actual. No debes pasar este puntero de un hilo a otro, o almacenarlo y utilizarlo en varios hilos. La Mquina Virtual de Java proporcionar el mismo puntero de interfaz cuando se invoque de forma consecutiva un mtodo nativo desde un mismo hilo. De todos modos, diferentes hilos pasan diferentes punteros de interfaz a los mtodos nativos. No se deben pasar referencias locales de un hilo a otro. En concreto, una referencia local debera convertirse en referencia invlida antes de que cualquier otro hilo pueda tener una oportunidad de utilizarla. Siempre que se d la situacin en que diferentes hilos tal vez tengan que usar la misma referencia a un objeto Java, se deberan convertir las referencias locales en referencias globales. Comprobar cuidadosamente el uso de variables globales. Varios hilos pueden estar accediendo a estas variables globales en el mismo instante de tiempo. Hay que asegurarse de poner los locks (cierres o controles de paso) apropiados para garantizar la seguridad.
Sincronizacin de hilos en mtodos nativos

La JNI proporciona dos funciones de sincronizacin que te permiten implementar bloques de sincronizacin. En Java propiamente dicho puedes implementar bloques de sincronizacin utilizando la sentencia synchronized. Por ejemplo: synchronized (obj) { . */ . . . } La Mquina Virtual de Java garantiza que un hilo debe haberse hecho con el monitor asociado con el objeto Java obj antes de que pueda ejecutar las sentencias interiores del bloque. De este modo, en cualquier instante de tiempo dado, slo puede haber como mucho un hilo ejecutndose dentro del bloque de sincronizacin. El cdigo nativo puede desarrollar una sincronizacin equivalente sobre los objetos utilizando las funciones que la JNI le proporciona, MonitorEnter y MonitorExit. Por ejemplo: . . .
/* bloque de sincronizacin
HILOS (THREADS)
(*env)->MonitorEnter(env, obj); . . . */ (*env)->MonitorExit(env, obj); . . /* bloque de sincronizacin
Hilos en applets. Ejemplos

Recordar que un applet se define como un programa Java que podemos incluir en una pgina HTML como si de una imagen se tratara. Un navegador que soporta la tecnologa Java presentar una pgina que contiene un applet, transfiriendo previamente el cdigo del applet al sistema local y ejecutndolo con su Mquina Virtual Java (JVM) (la del navegador). Este apartado aborda tres ejemplos de uso de los hilos en applets. Dado que no se hace ningn inciso en el cdigo bsico de los hilos, se recomienda consultar los apartados anteriores para entender el uso de los mismos. El primer applet, AnimatorApplet, muestra cmo usar un hilo para desarrollar una tarea repetitiva. El segundo ejemplo razona el uso de hilos para llevar a cabo inicializaciones de relativo coste. Por ltimo, se presenta un ejemplo un poco ms extenso de uso de hilos con concurrencia.
Uso de un hilo para desarrollar una tarea repetitiva

Por lo general, un applet que desarrolla la misma tarea una y otra vez, debera tener un hilo conun bucle while (o do ... while) que desarrolle dicha tarea. Un ejemplo tpico es un applet que realiza una animacin temporizada, como un reproductor de pelculas o un juego. Los applets de animacin necesitan un hilo que solicite un repintado a intervalos de tiempo regulares. Otro ejemplo sera un applet que lee datos proporcionados por una aplicacin servidora. Por lo general, los applet crean hilos para tareas repetitivas en el mtodo create del applet. La creacin de un hilo ah supone que sea ms fcil para el applet detener el hilo cuando el usuario abandone la pgina. Todo lo que necesitas hacer es implementar el mtodo stop de modo que detenga el hilo del applet. Cuando el usuario vuelva a la pgina del applet, entonces el mtodo start es invocado de nuevo, y el applet puede crear de nuevo un hilo para desarrollar la tarea repetitiva.
Uso de un hilo para desarrollar una inicializacin de una sola vez

Si un applet necesita llevar a cabo alguna tarea de inicializacin que suponga un cierto tiempo, se debera considerar alguna forma de realizar la inicializacin en un hilo. Por ejemplo, cualquier cosa que requiera hacer una conexin de red debera ser llevada a cabo, por lo general, en un hilo en un segundo plano. Afortunadamente, la descarga de imgenes GIF y JPEG se realiza automticamente en segundo plano utilizando hilos de los cuales no nos tenemos que preocupar. La descarga de sonido, por desgracia, no est garantizado que se realice en segundo plano. En implementaciones actuales, los mtodos del Applet getAudioClip no retornan hasta que hayan cargado
Pgina 31
HILOS (THREADS)
todos los datos de audio. Como consecuencia, si se quiere descargar datos de audio, se debera crear uno o ms hilos para llevarlo a cabo. Utilizar un hilo para desarrollar una tarea de inicializacin de un golpe para un applet es una variante del escenario clsico productor/consumidor. El hilo que desarrolla la tarea es el productor, y el applet es el consumidor.
Hilos en servlets.
Un servlets es un programa Java que se ejecuta en un servidor web. Los clientes pueden invocarlo mediante el protocolo HTTP. Del mismo modo que un applets es cargado y ejecutado en el navegador en la maquina cliente, un servlet es cargado y ejecutado por el servidor web. As en su uso ms habitual, un servlet acepta peticiones de cliente, procesa la informacin y devuelve los resultados, que podrn ser visualizados mediante applets, pginas HTML, etc. Cuando un proceso se inicia en un servidor, necesita la asignacin de varios recursos. El cambio entre procesos implica tambin mucha sobrecarga debido al cambio de contexto al tener que grabar toda la informacin de un proceso para volver ms tarde a l. A un proceso se le puede llamar hilo pesado debido a que inicia un proceso completo, con una enorme cantidad de sobrecarga en trminos de tiempo, memoria, etc... Por el contrario, por cada peticin a un servlet, se crea un hilo ligero para manejarla. Un hilo ligero es un proceso hijo, que es controlado por el proceso padre (en este caso, el servidor). En tal escenario, el cambio de contexto se hace muy fcil, y los hilos pueden pasar fcilmente de activos a inactivos, o a espera. Esto mejora sustancialmente el rendimiento de los servlets sobre los scripts CGI. Todo servlet debe directa o indirectamente implementar su interfaz. Como cualquier otro interfaz de Java, este es tambin una coleccin de declaraciones vacas de mtodos. Uno de los mtodos que estn declarados en el interfaz Servlet es: public abstract void destroy ()El mtodo destroy se invoca para liberar todos los recursos solicitados. Tambin se encarga de la sincronizacin de cualquier hilo pendiente. Este mtodo se llama una sola vez, automticamente, como el mtodo init.
ORGANIZACIN DE LOS HILOS DE UN PROCESO.

Otra forma de estudiar las posibilidades de emplear los hilos es pensar en trminos de modelos de programacin. La programacin multihilo es especialmente til en algunos modelos de programacin. Los hilos se pueden organizar de distintas formas para que cooperen entre s en la resolucin de un problema. Existen una serie de modelos tpicos de organizacin de los hilos de un proceso. Veamos cada modelo aplicado al ejemplo del servidor de archivos:
Modelo servidor/trabajador:
En este modelo un hilo funciona como supervisor asignando tareas a los hilos trabajadores. Despus de que el trabajador ha finalizado su tarea, lo indica al supervisor o es el supervisor quien lo comprueba por s mismo, para despus recibir una nueva tarea. Es el modelo empleado en el primer ejemplo del servidor de archivos. Un hilo servidor que obtiene las solicitudes y las redirige a los hilos trabajadores, que realizan el servicio.
HILOS (THREADS)
Modelo de cola de trabajo

Este modelo es una variante del modelo servidor/trabajador. En este modelo las tareas son colocadas por el servidor o supervisor en una cola que es accedida por los trabajadores hasta que se vaca.
Modelo de equipo
En este modelo mltiples hilos trabajan juntos en una tarea simple. Cada hilo realiza una parte de la tarea, como una casa en la que cada pintor pinta una parte de la misma. Todos los hilos son iguales, y cada uno obtiene y procesa sus propias solicitudes. No existe un hilo servidor. Se puede asociar una cola de trabajo a cada tipo de solicitud, de tal forma que existan tantas categoras de hilos como tipos de solicitud. Un hilo slo dar servicio a un tipo de solicitud, teniendo preferencia las solicitudes en espera en la cola correspondiente frente a las solicitudes del buzn del sistema.
Pgina 33
HILOS (THREADS)
Diseo de un paquete de hilos

Es posible implementar una biblioteca de hilos que soporte planificacin preemptiva, rpidos cambios de contexto entre hilos, secciones crticas pequeas, evite el crecimiento ilimitado de la pila, emplee pocas llamadas al sistema, y proporcione un interfaz independiente del lenguaje. Un paquete de hilos consiste de un conjunto de primitivas relacionadas con la gestin de los hilos, y disponibles para que el programador realice aplicaciones multihilo. El paquete de hilos tambin se encargar de gestionar, controlar, crear y destruir los hilos que la aplicacin multihilo requiere para su ejecucin. Los paquetes de hilos suelen tener tambin llamadas para especificar el tipo de algoritmo de planificacin deseado para los hilos: round-robin, prioridades, etc., as como establecer las prioridades en su caso. Para maximizar el rendimiento de la biblioteca de hilos, las llamadas al kernel del sistema operativo deben ser minimizadas. La sobrecarga asociada cuando se entra y se sale del kernel del sistema hace que las llamadas al sistema sean operaciones muy costosas. La mayora de las llamadas que debe realizar el paquete estarn relacionadas con la inicializacin de la biblioteca y otra serie de etapas que no sean crticas en tiempo.
Existen dos formas de gestionar los hilos:

a) Diseo de Hilos Estticos : El numero de hilos se fija al escribir el programa o durante la compilacin. Cada hilo tiene asociada un pila fija. Es una alternativa simple pero inflexible. b) Diseo de Hilos Dinmicos : Se permite la creacin y destruccin de hilos durante la ejecucin. En este modelo un proceso se inicia con un slo hilo (de manera implcita), pero puede crear ms hilos posteriormente. Este suele ser el diseo habitual empleado en los paquetes de hilos actuales. Existe una llamada para la creacin de hilos que determina el programa principal del hilo, para ello se pasa a la llamado un puntero al procedimiento principal, un tamao para la pila del hilo, y otra serie de parmetros, como puede ser la prioridad de planificacin. La llamada devuelve un identificador del hilo. La sintaxis abstracta de la llamada de creacin de hilos es id_Hilo CreateThread(puntero_procedimiento, tamao_pila, Parametros...) Un hilo puede finalizar su ejecucin por dos razones (al igual que un proceso) : la terminacin natural de su trabajo o su eliminacin desde el exterior.
Estructura bsica.
El estndar POSIX Threads especifica un modelo de hilos dirigido por prioridades con polticas de planificacin preemptivas, gestin de seales, y primitivas para proporcionar exclusin mutua as como espera sincronizada. El diseo de un paquete de hilos suele estar influenciado por las restricciones impuestas por el estndar POSIX Threads (si se desea seguir dicho estndar, caso habitual) y el tipo de plataforma sobre la que se va a implementar. Normalmente el diseo del paquete intenta reducir al mnimo la cantidad de cdigo dependiente de la plataforma, y se suele aislar en mdulos concretos, de forma que la biblioteca sea adaptable a nuevas plataformas.
HILOS (THREADS)
En la mayora de las implementaciones, el interfaz consiste en una biblioteca C con puntos de entrada enlazables, de forma que pueda ser compilada para generar un interfaz de lenguaje independiente. Este es el caso de la implementacin Pthreads realizada por Frank Mueller como base del proyecto PART (Portable Ada Run-Time), en el que se implementa un sistema de tiempo de ejecucin para la gestin de tareas Ada apoyado en la biblioteca de hilos.
Paquete de hilos de nivel usuario.

El paquete se implementa en el espacio de usuario, sin que el ncleo conozca su existencia. El ncleo sigue manejando procesos con un nico hilo.
Paquete de hilos de nivel kernel.

En este tipo de paquetes el ncleo gestiona los hilos. No se necesita un sistema de tiempo de ejecucin como en el caso de los hilos a nivel de usuario.
Pgina 35
HILOS (THREADS)
VENTAJAS DE LOS HILOS

La principal ventaja de los hilos es el rendimiento. Normalmente el rendimiento es una cantidad percibida y no dada. Unas aplicaciones se beneficiarn de los hilos mientras que otras no. Como se suele decir "el nmero de kilmetros puede variar". Existen un gran nmero de ventajas para emplear los hilos de usuario as como los hilos del ncleo : 1. Ejecucin paralela: Los hilos de nivel kernel se pueden ejecutar realmente en paralelo en mquinas SMP (Symmetric Multiprocessors). Adems el mismo cdigo binario es vlido tanto para una mquina de un procesador como una mquina multiprocesador. 2. Ejecucin de cdigo asncrono: Ya que existen mltiples hilos de ejecucin en un programa construido con hilos, es posible que otro hilo del mismo proceso sea planificado para ejecutar en el caso de que el hilo de ejecucin actual se bloquee. Esto incrementa la probabilidad de que la aplicacin asociada se ejecute mucho ms rpido. Normalmente existen algunas cosas a tener en cuenta : 3. 1. En el modelo de hilos de usuario, algunos bloqueos bloquearn todo el proceso y se planificar un proceso diferente. 2. En el modelo de hilos de ncleo, es posible que un hilo de otro proceso sea planificado cuando sucede un bloqueo del hilo actual. 3. En ambos modelos, un hilo puede bloquearse y pueden no existir otros hilos listos para ejecutarse en el proceso, por cualquier tipo de razones. As pues, el incremento del rendimiento no siempre est garantizado, aunque al menos, el uso de los hilos puede incrementar la probabilidad de un mejor rendimiento. 1. Recursos compartidos: Los hilos comparten la mayora de los recursos en un proceso. Comparten el acceso a los ficheros, memoria compartida, y el espacio de direcciones virtual. El empleo de los hilos permite a los programadores conservar los recursos del sistema. El rendimiento puede beneficiarse tambin porque los recursos compartidos entre hilos necesitan menos gestin que los recursos compartidos entre procesos. 2. Velocidad de las operaciones con hilos: Los hilos tienen un menor contexto que los procesos, as pues, las operaciones con hilos son
HILOS (THREADS)
generalmente ms rpidas que las operaciones similares con procesos. En especial, la creacin, finalizacin y cambio de contexto de un hilo, son operaciones ms rpidas con los hilos que con los procesos. Como ejemplo, en los procesadores de propsito general (SPARC, MIPS, ALPHA, HP-PA, x86) el cambio de contexto entre hilos de un mismo proceso lleva del orden de 50us. mientras que el cambio de contexto entre hilos de distintos procesos lleva del orden de 100us. Estos tiempos son muy inferiores al tiempo de cambio de contexto completo entre procesos. As en Solaris la creacin de un proceso es unas 30 veces ms lento que la creacin de un hilo, las variables de sincronizacin son unas 10 veces ms lentas y el cambio de contexto unas 5 veces ms lento.
3. Tiempo de respuesta: Si es posible separar operaciones en un programa, los hilos se pueden emplear para mejorar los tiempos de respuesta de la aplicacin. Por ejemplo, supongamos que estamos usando una utilidad de correo electrnico. En una versin de un solo hilo, mientras almacenamos un mensaje podemos apreciar algn retraso antes de que la interfaz de usuario sea refrescada. Esto es porque el programa est primero haciendo una operacin de E/S para almacenar el mensaje y despus refresca la pantalla. Estas operaciones las realiza de forma secuencial. Normalmente, si esta aplicacin fuese una versin programada con varios hilos, un hilo podra gestionar la E/S mientras otro hilo gestiona la interfaz de usuario. Estas operaciones pueden funcionar en paralelo, con la consiguiente ganancia en el tiempo de respuesta. 4. Programacin natural: Esta ventaja no est relacionada con el rendimiento, pero es importante. En algunas aplicaciones, el diseador puede necesitar instrucciones del tipo 'goto' y otros mtodos para superar las limitaciones de la programacin secuencial tradicional. Sin embargo, con los hilos, el programador no est limitado a emplear un modelo de ejecucin secuencial. As, las limitaciones de la programacin secuencial pueden solucionarse de forma ms intuitiva, menos compleja y ms natural, incluso empleando otros modelos de programacin, como la programacin concurrente. Adems muchos problemas son ms fciles de plantear y programar con un modelo de hilos debido a su estructura concurrente. 5. Existe un estndar (POSIX 1003.1c) lo que permite hacer a las aplicaciones portables entre distintas plataformas. El mismo cdigo fuente es vlido para distintas plataformas. 6. Objetos distribuidos : Con la aparicin del estndar de objetos distribuidos CORBA, los hilos toman un papel especial e importante. Los objetos distribuidos tienen una estructura multihilo inherentemente. Cada vez que se pide que un objeto realice una accin, el objeto ejecuta la accin mediante un hilo independiente, de forma que el objeto puede haber ms de un hilo al mismo tiempo. Adems los servidores de objetos se pueden construir con hilos de forma ms efectiva y con un mayor rendimiento.
Pgina 37
HILOS (THREADS)
PROBLEMAS POTENCIALES DE LOS HILOS

Algunos autores, como John Ousterhout [OUS94], consideran que los hilos slo deben emplearse cuando se desea y es posible una concurrencia verdadera, y no en entornos uniprocesador. Consideran que son demasiado complicados de usar para la mayora de los programadores, incluso para los expertos, y plantean la programacin con eventos como alternativa para la mayora de los casos. Las problemas se deben a las siguientes causas : 1. Complejidad: Aunque es cierto que la programacin con hilos puede proporcionar una forma ms natural de resolver los problemas, existen otras cosas que se deben tener en cuenta. La programacin con hilos es ms difcil que la clsica programacin secuencial. Por ejemplo, cuando se mantiene, depura u optimiza una aplicacin con hilos, se deben tener en cuenta la existencia de mltiples hilos de cdigo en ejecucin. Por ello generalmente es ms fcil depurar y optimizar un programa de hilo simple. 2. Sincronizacin: Se debe coordinar el acceso a los datos compartidos mediante bloqueos. Olvidar un bloqueo puede producir la corrupcin de los datos. 3. Posibilidad de deadlock: Las dependencias circulares en los bloqueos pueden originar deadlock. 4. Depuracin difcil: debido a las dependencias entre los datos y las dependencias de tiempo. Depurar en un sistema multiprocesador es ms complicado, ms costoso, y los errores no siempre son reproducibles. Una biblioteca de hilos puede ser til para detectar y analizar errores en un entorno uniprocesador antes de ser probada en un sistema multiprocesador. Existen dos tipos de errores, los errores serie que pueden ocurrir en un entorno uniprocesador, y los errores paralelos que son inherentes a una ejecucin paralela, y son difciles de detectar. 5. Rompen la abstraccin: lo que impide disear mdulos independientes. 6. Obtener un buen rendimiento es difcil. Los bloqueos demasiado simples (grano grueso) disminuyen el nivel de concurrencia, mientras que los bloqueos de grano fino son demasiado complicados. Adems la velocidad de cambio de contexto del sistema operativo influye notablemente en el rendimiento. 7. Soporte escaso: El cdigo es difcil de transportar a otras arquitecturas que no soportan hilos. Las libreras estndar no suelen ser hilo-seguras. Las llamadas al kernel o al sistema de gestin de ventanas pueden no estar preparadas para soportar mltiples hilos. 8. Disponibilidad de herramientas: Para favorecer el desarrollo de aplicaciones multihilo, la industria necesitar crear herramientas de depuracin y optimizacin ms refinadas. Sin embargo, la tecnologa de los depuradores y optimizadores es relativamente joven lo que a corto plazo supone un problema para los programadores. Un entorno de programacin multihilo debe proporcionar depuradores con soporte multihilo [CAS90]. La informacin debe ser extrada del TCB (bloque de control del hilo) y hacerla disponible al usuario. Los cambios de contexto deberan ser visibles para el usuario. Por ejemplo, cuando se va a producir un cambio de contexto, el usuario podra elegir si continua depurando despus del punto de suspensin o si cambia al contexto de otro hilo. Adems se podran presentar ventanas de depuracin separadas para cada hilo dentro de un proceso. 9. Utilizacin de cdigo no seguro: Se debe tener mucho cuidado a la hora de mezclar cdigo multihilo con cdigo no hilo-seguro, es decir, cdigo no preparado para ejecucin en un entorno multihilo.
HILOS (THREADS)
Implementacin de barreras.
Una barrera es un punto de sincronizacin entre varios hilos. Esta tcnica permite que varios hilos se sincronicen en un determinado punto de su ejecucin, de forma que ninguno de ellos puede avanzar en su ejecucin hasta que todos hayan alcanzado el punto establecido por la barrera. Con esta tcnica se pueden implementar algoritmos SIMD en sistemas MIMD de una forma sencilla.
Computacin multihilo.
El modelo de computaciones paralelas multihilo fue descrito por Bell(1992), y se presenta en la siguiente figura :
Modelo de computacin multihilo.

La computacin comienza con un hilo secuencial (1), seguido por una planificacin (2) donde los procesadores inician los hilos de la computacin (3), a travs de mensajes entre computadoras que actualizan las variables entre los nodos donde existe memoria distribuida (4), y finalmente mediante sincronizacin (5) antes del comienzo de la siguiente unidad de trabajo paralelo. El periodo de sobrecarga de comunicacin (3) inherente en las estructuras de memoria distribuida est normalmente distribuido en toda la computacin y est solapado
HILOS (THREADS)
completamente. La sobrecarga del paso de mensajes debido a las llamadas receive y send en los multicomputadores puede reducirse mediante hardware especializado operando en paralelo con la computacin. El ancho de banda de la comunicacin limita la granularidad, ya que se debe transferir cierta cantidad de datos a otros nodos para completar un grano de la computacin. Las llamadas de paso de mensajes (4) y sincronizacin (5) son no productivas. Son necesarios mecanismos rpidos para reducir u ocultar estos retrasos. El mutithreading no es capaz de incrementar la velocidad en la ejecucin de hilos simples, mientras que los modelos de consistencia dbiles son capaces de hacerlo.
PROCESOS LIGEROS HILOS O HEBRAS
El concepto de proceso engloba dos conceptos separados y potencialmente independientes: uno relativo a la propiedad de recursos y otro que hace referencia a la ejecucin.
Unidad que posee recursos: A un proceso se le asigna un espacio de memoria y, de tanto en tanto, se le puede asignar otros recursos como dispositivos de E/S o ficheros. Unidad a la que se le asigna el procesador: Un proceso es un flujo de ejecucin (una traza) a travs de uno o ms programas. Esta ejecucin se entremezcla con la de otros procesos. De tal forma, que un proceso tiene un estado (en ejecucin, listo, etc) y una prioridad de expedicin u origen. La unidad planificada y expedida por el sistema operativo es el proceso. Dentro de un proceso puede haber uno o ms hilos de control cada uno con: Un estado de ejecucin (en ejecucin, listo, bloqueado). Un contexto de procesador, que se salva cuando no est ejecutndose.
Pgina 40
HILOS (THREADS)
Una pila de ejecucin. Algn almacenamiento esttico para variables locales. Acceso a la memoria y a los recursos de ese trabajo que comparte con los otros hilos.
CARACTERISTICAS

Se comparten recursos. La comparticin de la memoria permite a las hebras pares comunicarse sin usar ningn mecanismo de comunicacin inter-proceso del SO. La conmutacin de contexto es ms rpida gracias al extenso compartir de recursos No hay proteccin entre las hebras. Una hebra puede escribir en la pila de otra hebra del mismo proceso Estado de los procesos ligeros
Pgina 41

Hilos (Threads)

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Hilos (Threads)

Cargado por

Copyright:

Formatos disponibles

HILOS (THREADS)

USP-Ingeniera Informtica y Sistemas

USP-Ingeniera Informtica y Sistemas

Diferencias entre hilos y procesos

Funcionalidad de los hilos

Ventajas de los hilos contra procesos

Hilos a nivel de usuario (ULT)

USP-Ingeniera Informtica y Sistemas

Hilos a nivel de ncleo (KLT)

Un hilo tendr lo siguiente:

USP-Ingeniera Informtica y Sistemas

Ventajas del uso de hilos.

Conceptos Bsicos sobre Hilos

Clases Relacionadas con los Hilos

USP-Ingeniera Informtica y Sistemas

USP-Ingeniera Informtica y Sistemas

USP-Ingeniera Informtica y Sistemas

Estado y Control de Hilos

USP-Ingeniera Informtica y Sistemas

En nuestro ejemplo sera:

USP-Ingeniera Informtica y Sistemas

El grupo de hilos por defecto

USP-Ingeniera Informtica y Sistemas

Creacin de un hilo en un grupo de forma explcita

USP-Ingeniera Informtica y Sistemas

Mtodos que operan sobre todos los hilos de un grupo

Mtodos de restriccin de acceso

USP-Ingeniera Informtica y Sistemas

Planificacin y Prioridad de Hilos

USP-Ingeniera Informtica y Sistemas

Ejemplo: carrera de hilos

USP-Ingeniera Informtica y Sistemas

Hilos Demonio (Daemon)

Funciones Miembro de la Clase Thread

USP-Ingeniera Informtica y Sistemas

Hilos y Mtodos Nativos

USP-Ingeniera Informtica y Sistemas

Sincronizacin de hilos en mtodos nativos

(*env)->MonitorEnter(env, obj); . . . */ (*env)->MonitorExit(env, obj); . . /* bloque de sincronizacin

Hilos en applets. Ejemplos

Uso de un hilo para desarrollar una tarea repetitiva

Uso de un hilo para desarrollar una inicializacin de una sola vez

USP-Ingeniera Informtica y Sistemas

ORGANIZACIN DE LOS HILOS DE UN PROCESO.

Modelo de cola de trabajo

USP-Ingeniera Informtica y Sistemas

Diseo de un paquete de hilos

Existen dos formas de gestionar los hilos:

Paquete de hilos de nivel usuario.

Paquete de hilos de nivel kernel.

USP-Ingeniera Informtica y Sistemas

VENTAJAS DE LOS HILOS

USP-Ingeniera Informtica y Sistemas

PROBLEMAS POTENCIALES DE LOS HILOS

Modelo de computacin multihilo.

PROCESOS LIGEROS HILOS O HEBRAS

USP-Ingeniera Informtica y Sistemas

USP-Ingeniera Informtica y Sistemas

También podría gustarte

(env)->MonitorEnter(env, obj); . . . / (env)->MonitorExit(env, obj); . . / bloque de sincronizacin