Hilo de ejecución

HILO DE EJECUCIÓN

Ms. Ing. Jairo E. Márquez D.

Introducción

“En SO, un hilo de ejecución o subprocesoes una característica que permite a unaaplicación realizar varias tareas a la vez(concurrentemente). Los distintos hilos deejecución comparten una serie de recursostales como el espacio de memoria, losarchivos abiertos, situación deautenticación, etc. Esta técnica permitesimplificar el diseño de una aplicación quedebe llevar a cabo distintas funcionessimultáneamente.

“Un hilo es básicamente una tarea que puede ser ejecutada en paralelo con otratarea.”

Los hilos de ejecución que comparten los mismos recursos, sumados a estos recursos,son en conjunto conocidos como un proceso. El hecho de que los hilos de ejecución deun mismo proceso compartan los recursos hace que cualquiera de estos hilos puedamodificar éstos. Cuando un hilo modifica un dato en la memoria, los otros hilos accedena ese dato modificado inmediatamente.

Lo que es propio de cada hilo es el contador de programa1, la pila de ejecución y elestado de la CPU (incluyendo el valor de los registros).

El proceso sigue en ejecución mientras al menos uno de sus hilos de ejecución sigaactivo. Cuando el proceso finaliza, todos sus hilos de ejecución también han terminado.Asimismo en el momento en el que todos los hilos de ejecución finalizan, el proceso noexiste más y todos sus recursos son liberados.

1 El contador de programa (Program Counter o PC) o Puntero de instrucciones, partedel secuenciador de instrucciones en algunas computadoras, es un registro del procesador que indica laposición donde está éste en su secuencia de instrucciones. Dependiendo de los detalles de la máquinaparticular, contiene o la dirección de la instrucción que es ejecutada, mientras que la próxima instruccióna ser ejecutada se maneja por el instruction pointer (IP). El contador de programa es incrementadoautomáticamente en cada ciclo de instrucción, de tal manera que las instrucciones son leídas en secuenciadesde la memoria. Ciertas instrucciones, tales como las bifurcaciones y las llamadas y retornosde subrutinas, interrumpen la secuencia al colocar un nuevo valor en el contador de programa.

En la inmensa mayoría de los procesadores, el puntero de instrucciones es incrementado inmediatamentedespués de leer (fetch) una instrucción de programa; esto significa que la dirección a la que apunta unainstrucción de bifurcación es obtenida agregando el operando de la instrucción de bifurcación a ladirección de la instrucción siguiente (byte o word, dependiendo del tipo de la computador) después de lainstrucción de bifurcación. La dirección de la siguiente instrucción a ser ejecutada siempre se encuentraen el contador de instrucción.

Algunos lenguajes de programación tienen características de diseño expresamentecreadas para permitir a los programadores lidiar con hilos de ejecución (como Java oDelphi2). Otros programas por no decir que la mayoría desconocen la existencia de hilosde ejecución y éstos deben ser creados mediante llamadas de biblioteca especiales quedependen del sistema operativo en el que estos lenguajes están siendo utilizados (comoes el caso del C y del C++).

Un ejemplo del uso de hilos es tener un hilo atento a la interfaz gráfica (iconos, botones,ventanas), mientras otro hilo hace una larga operación internamente. De esta manera elprograma responde de manera más ágil a la interacción con el usuario. También puedenser utilizados por una aplicación servidora para dar servicio a múltiples clientes.”3

Hilos

Muchos S. O. distribuidos soportan múltiples hilos de control dentro de unproceso que [25, Tanenbaum]:4

Comparten un único espacio de direcciones. Se ejecutan quasi - paralelamente como si fueran procesos independientes.

Ej.: servidor de archivos que debe bloquearse ocasionalmente en espera de acceso aldisco:

2 Es un entorno de desarrollo de software diseñado para la programación de propósito general con énfasisen la programación visual. En Delphi se utiliza como lenguaje de programación una versión moderna dePascal llamada Object Pascal. En sus diferentes variantes, permite producir archivos ejecutables paraWindows, GNU/Linux y la plataforma .NET.

Un uso habitual de Delphi, aunque no el único, es el desarrollo de aplicaciones visuales y de bases dedatos cliente-servidor y multicapas. Debido a que es una herramienta de propósito múltiple, se usatambién para proyectos de casi cualquier tipo, incluyendo aplicaciones de consola, aplicaciones de web(por ejemplo servicios web, CGI, ISAPI, NSAPI, módulos para Apache), servicios COM y DCOM, yservicios del SO. Entre las aplicaciones más populares actualmente destaca Skype, un programa detelefonía por IP.

Delphi inicialmente sólo producía ejecutables binarios para Windows: Delphi 1 para Win16 y con Delphi2 se introdujo Win32. En la actualidad da más posibilidades, como son:

Delphi para Win32 Delphi para .NET Delphi para PHP C# para .NET C++

Existe una versión de Delphi para sistemas Unix y Linux, denominada Kylix (de la cual existe unaversión gratuita, aunque limitada). Sin embargo Kylix fue congelado por Borland en su versión 3.00.3 Fuente de consulta. Hilo de ejecución. http://es.wikipedia.org/wiki/Hilo_de_ejecuci%C3%B3n [Online] Consultado el 7 de octubre de 2012.4 Fuente de consulta. Procesos y procesadores en sistemas distribuidos.http://exa.unne.edu.ar/depar/areas/informatica/SistemasOperativos/SOF.htm [On line] Consultado el 12de agosto de 2012.

Si tiene varios hilos de control podría ejecutar un segundo hilo mientras elprimero espera:

o El resultado sería mejor rendimiento y desempeño.o No se logra esto con procesos servidores independientes puesto que

deben compartir un buffer caché común y deben estar en el mismoespacio de direcciones.

En muchos sentidos los hilos son como miniprocesos:

Cada hilo:o Se ejecuta en forma estrictamente secuencial.o Tiene su propio contador de programa y una pila para llevar un registro

de su posición. Los hilos comparten la cpu de la misma forma que lo hacen los procesos:

o Secuencialmente, en tiempo compartido. Solo en un multiprocesador se pueden ejecutar realmente en paralelo. Los hilos pueden crear hilos hijos. Mientras un hilo está bloqueado se puede ejecutar otro hilo del mismo proceso.

Los distintos hilos de un proceso comparten un espacio de direcciones, el conjunto dearchivos abiertos, los procesos hijos, cronómetros, señales, etc.

Los hilos pueden tener distintos estados: en ejecución, bloqueado, listo, terminado.

Uso de Hilos5

Los hilos permiten la combinación del paralelismo con la ejecución secuencial y elbloqueo de las llamadas al sistema [25, Tanenbaum].

Consideramos el ejemplo del servidor de archivos con sus posibles organizaciones paramuchos hilos de ejecución.

Iniciamos con el modelo servidor / trabajador:

Un hilo, el servidor, lee las solicitudes de trabajo en el buzón del sistema. Elige a un hilo trabajador inactivo (bloqueado) y le envía la solicitud,

despertándolo. El hilo trabajador verifica si puede satisfacer la solicitud por medio del bloque

caché compartido, al que tienen acceso todos los hilos. Si no envía un mensaje al disco para obtener el bloque necesario y se duerme

esperando el fin de la operación. Se llama:

o Al planificador y se inicializa otro hilo, que tal vez sea el servidor, parapedir más trabajo; o.

o A otro trabajador listo para realizar un trabajo.

Los hilos ganan un desempeño considerable pero cada uno de ellos se programa enforma secuencial.

5 Ibid.

Otro modelo es el de equipo:

Todos los hilos son iguales y cada uno obtiene y procesa sus propias solicitudes. No hay servidor. Se utiliza una cola de trabajo que contiene todos los trabajos pendientes, que son

trabajos que los hilos no han podido manejar. Un hilo debe verificar primero la cola de trabajo antes de buscar en el buzón del

sistema.

Un tercer modelo es el de entubamiento:

El primer hilo genera ciertos datos y los transfiere al siguiente para suprocesamiento.

Los datos pasan de hilo en hilo y en cada etapa se lleva a cabo ciertoprocesamiento.

Un programa diseñado adecuadamente y que utilice hilos debe funcionar bien:

En una única CPU con hilos compartidos. En un verdadero multiprocesador.

Un thread (hilo de ejecución), en sistemas operativos y por extensión en sistemasvirtualizados, es una característica que permite a una aplicación realizar varias tareas ala vez (concurrentemente). Los distintos hilos de ejecución comparten una serie derecursos tales como el espacio de memoria, los archivos abiertos, situación deautenticación, etc. Esta técnica permite simplificar el diseño de una aplicación que debellevar a cabo distintas funciones simultáneamente.

Los hilos no pueden ejecutarse ellos solos; requieren la supervisión de un proceso padrepara correr.

Dentro de cada proceso hay varios hilos ejecutándose. Por ejemplo, Word puede tenerun hilo en background chequeando automáticamente la gramática de lo que se está

escribiendo, mientras otro hilo puede estar salvando automáticamente los cambios deldocumento en el que se trabaja.

Como Word, cada aplicación (proceso) puede correr varios hilos los cuales estánrealizando diferentes tareas. Esto significa que los hilos están siempre asociados con unproceso en particular.

Los hilos a menudo son conocidos o llamados procesos ligeros. Un hilo, en efecto, esmuy similar a un proceso pero con la diferencia de que un hilo siempre corre dentro delcontexto de otro programa. Por el contrario, los procesos mantienen su propio espaciode direcciones y entorno de operaciones.

Los hilos dependen de un programa padre en lo que se refiere a recursos de ejecución.La siguiente figura muestra le relación entre hilos y procesos.

Un programa de flujo único o mono-hilvanado (single-thread) utiliza un único flujo decontrol (thread) para controlar su ejecución. Muchos programas no necesitan la potenciao utilidad de múltiples flujos de control. Sin necesidad de especificar explícitamente quese quiere un único flujo de control, muchos de los applets y aplicaciones son de flujoúnico.

Por ejemplo, usando Java para la aplicación estándar de saludo:

public class HolaMundo{

static public void main( String args[] ){

System.out.println( "Hola Mundo!" );}

}

Aquí, cuando se llama a main(), la aplicación imprime el mensaje y termina. Esto ocurredentro de un único thread.

La clase Thread

Es la clase que encapsula todo elcontrol necesario sobre los hilos deejecución (threads). Hay quedistinguir claramente un objetoThread de un hilo de ejecución othread. Esta distinción resultacomplicada, aunque se puedesimplificar si se considera al objetoThread como el panel de control deun hilo de ejecución (thread). La

clase Thread es la única forma de controlar el comportamiento de los hilos y para ello sesirve de los métodos que se exponen en las secciones siguientes.

Métodos de Clase

Estos son los métodos estáticos que deben llamarse de manera directa en la claseThread.

currentThread()

Este método devuelve el objeto thread que representa al hilo de ejecución que se estáejecutando actualmente.

yield()

Este método hace que el intérprete cambie de contexto entre el hilo actual y el siguientehilo ejecutable disponible. Es una manera de asegurar que nos hilos de menor prioridadno sufran inanición.

sleep( long )

El método sleep() provoca que el intérprete ponga al hilo en curso a dormir durante elnúmero de milisegundos que se indiquen en el parámetro de invocación. Una veztranscurridos esos milisegundos, dicho hilo volverá a estar disponible para su ejecución.Los relojes asociados a la mayor parte de los intérpretes de Java no serán capaces deobtener precisiones mayores de 10 milisegundos, por mucho que se permita indicarhasta nanosegundos en la llamada alternativa a este método.

Métodos de Instancia

Aquí no están recogidos todos losmétodos de la clase Thread, sinosolamente los más interesantes, porquelos demás corresponden a áreas endonde el estándar de Java no estácompleto, y puede que se quedenobsoletos en la próxima versión delJDK, por ello, si se desea completar lainformación que aquí se expone se hade recurrir a la documentación delinterfaz de programación de aplicación(API) del JDK.

start()

Este método indica al intérprete de Java que cree un contexto del hilo del sistema ycomience a ejecutarlo. A continuación, el método run() de este hilo será invocado en elnuevo contexto del hilo. Hay que tener precaución de no llamar al método start() más deuna vez sobre un hilo determinado.

run()

El método run() constituye el cuerpo de un hilo en ejecución. Este es el único métododel interfaz Runnable. Es llamado por el método start() después de que el hilo apropiado

del sistema se haya inicializado. Siempre que el método run() devuelva el control, elhilo actual se detendrá.

stop()

Este método provoca que el hilo sedetenga de manera inmediata. Amenudo constituye una manera bruscade detener un hilo, especialmente si estemétodo se ejecuta sobre el hilo en curso.En tal caso, la línea inmediatamenteposterior a la llamada al método stop()no llega a ejecutarse jamás, pues elcontexto del hilo muere antes de questop() devuelva el control. Una formamás elegante de detener un hilo esutilizar alguna variable que ocasioneque el método run() termine de manera ordenada. En realidad, nunca se debería recurriral uso de este método.

suspend()

El método suspend() es distinto de stop(). suspend() toma el hilo y provoca que sedetenga su ejecución sin destruir el hilo de sistema subyacente, ni el estado del hiloanteriormente en ejecución. Si la ejecución de un hilo se suspende, puede llamarse aresume() sobre el mismo hilo para lograr que vuelva a ejecutarse de nuevo.

resume()

El método resume() se utiliza para revivir un hilo suspendido. No hay garantías de queel hilo comience a ejecutarse inmediatamente, ya que puede haber un hilo de mayorprioridad en ejecución actualmente, pero resume() ocasiona que el hilo vuelva a ser uncandidato a ser ejecutado.

setPriority( int )

El método setPriority() asigna al hilo la prioridad indicada por el valor pasado comoparámetro. Hay bastantes constantes predefinidas para la prioridad, definidas en la claseThread, tales como MIN_PRIORITY, NORM_PRIORITY y MAX_PRIORITY, quetoman los valores 1, 5 y 10, respectivamente. Como guía aproximada de utilización, sepuede establecer que la mayor parte de los procesos a nivel de usuario deberían tomaruna prioridad en torno a NORM_PRIORITY. Las tareas en segundo plano, como unaentrada/salida a red o el nuevo dibujo de la pantalla, deberían tener una prioridadcercana a MIN_PRIORITY. Con las tareas a las que se fije la máxima prioridad, entorno a MAX_PRIORITY, hay que ser especialmente cuidadosos, porque si no se hacenllamadas a sleep() o yield(), se puede provocar que el intérprete Java quede totalmentefuera de control.

getPriority()

Este método devuelve la prioridad del hilo de ejecución en curso, que es un valorcomprendido entre uno y diez.

setName( String )

Este método permite identificar al hilo con un nombre menmónico. De esta manera sefacilita la depuración de programas multihilo. El nombre mnemónico aparecerá en todaslas líneas de trazado que se muestran cada vez que el intérprete Java imprimeexcepciones no capturadas.

getName()

Este método devuelve el valor actual, de tipo cadena, asignado como nombre al hilo enejecución mediante setName().

Diferencias entre hilos y procesos6

Los hilos se distinguen de lostradicionales procesos en que losprocesos son –generalmente–independientes, llevan bastanteinformación de estados, einteractúan sólo a través demecanismos de comunicacióndados por el sistema. Por otra parte,muchos hilos generalmentecomparten otros recursos de formadirecta. En muchos de los SO quedan facilidades a los hilos, es másrápido cambiar de un hilo a otrodentro del mismo proceso, quecambiar de un proceso a otro. Este fenómeno se debe a que los hilos comparten datos yespacios de direcciones, mientras que los procesos, al ser independientes, no lo hacen.Al cambiar de un proceso a otro, el SO (mediante el dispatcher7) genera lo que seconoce como overhead, que es tiempo desperdiciado por el procesador para realizar uncambio de contexto (context switch), en este caso pasar del estado de ejecución(running) al estado de espera (waiting) y colocar el nuevo proceso en ejecución. En loshilos, como pertenecen a un mismo proceso, al realizar un cambio de hilo el tiempoperdido es casi despreciable.

Al igual que los procesos, los hilos poseen un estado de ejecución y puedensincronizarse entre ellos para evitar problemas de compartimiento de recursos.Generalmente, cada hilo tiene una tarea específica y determinada, como forma deaumentar la eficiencia del uso del procesador.

6 Fuente de consulta. Hilo de ejecución. http://es.wikipedia.org/wiki/Hilo_de_ejecuci%C3%B3n [Online] Consultado el 7 de octubre de 2012.

7 Parte de un programa encargada de lanzar un proceso en el servidor de un entorno cliente/servidor.

Estados de un hilo

Los principales estados de los hilos son: Ejecución, Listo y Bloqueado. No tienesentido asociar estados de suspensión de hilos ya que es un concepto de proceso. Entodo caso, si un proceso está expulsado de la memoria principal (RAM), todos sus hilosdeberán estarlo ya que todos comparten el espacio de direcciones del proceso.

Cambio de estados

Creación: Cuando se crea un proceso se crea un hilo para ese proceso. Luego,este hilo puede crear otros hilos dentro del mismo proceso, proporcionando unpuntero de instrucción y los argumentos del nuevo hilo. El hilo tendrá su propiocontexto y su propio espacio de la columna, y pasara a la final de los listos.

Bloqueo: Cuando un hilo necesita esperar por un suceso, se bloquea (salvandosus registros de usuario, contador de programa y punteros de pila). Ahora elprocesador podrá pasar a ejecutar otro hilo que esté en la final de los Listosmientras el anterior permanece bloqueado.

Desbloqueo: Cuando el suceso por el que el hilo se bloqueó se produce, elmismo pasa a la final de los Listos.

Terminación: Cuando un hilo finaliza se liberan tanto su contexto como suscolumnas.

Ventajas de los hilos contra procesos

Los hilos son generados a partir de la creación de un proceso, por ende, un proceso esun hilo de ejecución o Monohilo. Las ventajas de los hilos se dan en los Multihilos, quees cuando un proceso tiene múltiples hilos de ejecución los cuales realizan actividadesdistintas, que pueden o no ser cooperativas entre sí. Los beneficios de los hilos sederivan de las implicaciones de rendimiento, así:

1. Se tarda mucho menos tiempo en crear un hilo nuevo en un proceso existenteque en crear un proceso. Algunas investigaciones llevan al resultado que esto esasí en un factor de 10.

2. Se tarda mucho menos en terminar un hilo que un proceso, ya que cuando seelimina un proceso se debe eliminar el BCP (Bloque de control del proceso, oPCB (Process Control Block)) 8 del mismo, mientras que un hilo se elimina sucontexto y pila.

8 Es un registro especial donde el SO agrupa toda la información que necesita conocer respecto a unproceso particular. Cada vez que se crea un proceso el SO crea el BCP correspondiente para que sirvacomo descripción en tiempo de ejecución durante toda la vida del proceso.

Cuando el proceso termina, su BCP es borrado y el registro puede ser utilizado para otros procesos. Unproceso resulta conocido para el SO y por tanto elegible para competir por los recursos del sistema sólocuando existe un BCP activo asociado a él. El bloque de control de proceso es una estructura de datos concampos para registrar los diferentes aspectos de la ejecución del proceso y de la utilización de recursos.La información almacenada en un BCP incluye típicamente algunos o todos los campos siguientes:

3. Se tarda mucho menos tiempo en cambiar entre dos hilos de un mismo proceso4. Los hilos aumentan la eficiencia de la comunicación entre programas en

ejecución. En la mayoría de los sistemas en la comunicación entre procesos debeintervenir el núcleo para ofrecer protección de los recursos y realizar lacomunicación misma. En cambio, entre hilos pueden comunicarse entre sí sin lainvocación al núcleo. Por lo tanto, si hay una aplicación que debe implementarsecomo un conjunto de unidades de ejecución relacionadas, es más eficientehacerlo con una colección de hilos que con una colección de procesos separados.

Sincronización de hilos

Todos los hilos comparten el mismoespacio de direcciones y otros recursoscomo pueden ser archivos abiertos.Cualquier modificación de un recurso desdeun hilo afecta al entorno del resto de loshilos del mismo proceso. Por lo tanto, esnecesario sincronizar la actividad de losdistintos hilos para que no interfieran unoscon otros o corrompan estructuras de datos.

Identificador del proceso (Process Identificator -PID-, de sus siglas en Inglés). Estado del proceso. Por ej. listo, en espera, bloqueado. Contador de Programa: Dirección de la próxima instrucción a ejecutar. Valores de registro de CPU. Se utilizan también en el cambio de contexto. Espacio de direcciones de memoria. Prioridad en caso de utilizarse dicho algoritmo para planificación de CPU. Lista de recursos asignados (incluyendo descriptores de archivos y sockets abiertos). Estadísticas del proceso. Datos del propietario (owner). Permisos asignados. Signals pendientes de ser servidos. (Almacenados en un mapa de bits)

Esta lista es simplemente indicativa, cada sistema operativo tiene su propio diseño de BCP, con elconjunto de metadatos necesarios para la administración. Puede medir desde 32 bits a 1024. Sudenominación cambia según el sistema operativo, por ej. en IBM se designa PSW por palabra de estadode proceso. Difiere significativamente entre los sistemas de procesamiento por lotes (BATCH) y lossistemas interactivos.

Algunos sistemas de multiprogramación incluyen información de mantenimiento con el propósito defacturar a los usuarios individuales el tiempo de procesador, el almacenamiento, las operaciones de E/S yotras utilizaciones de recursos.

Una vez creado, el BCP se rellena con los atributos definidos como parámetros que se hallan en laplantilla del proceso o que son especificados como parámetros de la llamada al SO crear_proceso. En esemomento el sistema operativo suele asignar valores a otros campos. Por ejemplo, cuando se crea unproceso, los registros e indicadores hardware se fijan a los valores proporcionados por elcargador/enlazador. Cada vez que un proceso queda suspendido, el contenido de los registros delprocesador es generalmente guardado en la pila, y el puntero al marco de la pila en cuestión se almacenaen el BCP. De este modo los valores de los registros son restaurados cuando el proceso es seleccionadopara ejecutarse nuevamente.

Una ventaja de la programación multihilo es que los programas operan con mayorvelocidad en sistemas de computadores con múltiples CPUs (sistemas multiprocesadoro a través de grupo de máquinas) ya que los hilos del programa se prestanverdaderamente para la ejecución concurrente.

En tal caso el programador necesita sercuidadoso para evitar condiciones decarrera (problema que sucede cuandodiferentes hilos o procesos alterandatos que otros también están usando),y otros comportamientos no intuitivos.Los hilos generalmente requierenreunirse para procesar los datos en elorden correcto. Es posible que los hilosrequieran de operaciones atómicas paraimpedir que los datos comunes seancambiados o leídos mientras esténsiendo modificados, para lo queusualmente se utilizan los semáforos9.El descuido de esto puede generarinterbloqueo10.

Formas de multihilos

Los sistemas operativos generalmente implementan hilos de dos maneras:

Multihilo apropiativo: permite al sistema operativo determinar cuándo debehaber un cambio de contexto. La desventaja de esto es que el sistema puedehacer un cambio de contexto en un momento inadecuado, causando unfenómeno conocido como inversión de prioridades y otros problemas.

Multihilo cooperativo: depende del mismo hilo abandonar el control cuandollega a un punto de detención, lo cual puede traer problemas cuando el hiloespera la disponibilidad de un recurso.

9 Un semáforo es una variable especial (o tipo abstracto de datos) que constituye el método clásico pararestringir o permitir el acceso a recursos compartidos (por ejemplo, un recurso de almacenamiento delsistema o variables del código fuente) en un entorno de multiprocesamiento (en el que se ejecutaránvarios procesos concurrentemente). Los semáforos pueden ser usados para diferentes propósitos, entreellos:

Implementar cierres de exclusión mutua o locks Barreras Permitir a un máximo de N threads (hilos) acceder a un recurso, inicializando el semáforo en N Notificación. Inicializando el semáforo en 0 puede usarse para comunicación entre threads sobre

la disponibilidad de un recurso

10 Es el bloqueo permanente de un conjunto de procesos o hilos de ejecución en un sistema concurrenteque compiten por recursos del sistema o bien se comunican entre ellos. A diferencia de otros problemasde concurrencia de procesos, no existe una solución general para los interbloqueos.

El soporte de hardware para multihilo se encuentra disponible desde hace relativamentepoco tiempo. Esta característica fue introducida por Intel en el Pentium 4, bajo elnombre de HyperThreading11.

Usos más comunes

Los usos más comunes son en tecnologías SMPP y SMS para la telecomunicacionesaquí hay muchísimos procesos corriendo a la vez y todos requiriendo de un servicio.- Trabajo interactivo y en segundo plano

Por ejemplo, en un programa de hoja de cálculo un hilo puede estar visualizando losmenús y leer la entrada del usuario mientras que otro hilo ejecuta las órdenes y actualizala hoja de cálculo. Esta medida suele aumentar la velocidad que se percibe en laaplicación, permitiendo que el programa pida la orden siguiente antes de terminar laanterior. - Procesamiento asíncrono

Los elementos asíncronos de un programa se pueden implementar como hilos. Unejemplo es como los software de procesamiento de texto guardan archivos temporalescuando se está trabajando en dicho programa. Se crea un hilo que tiene como funciónguardar una copia de respaldo mientras se continúa con la operación de escritura por elusuario sin interferir en la misma.- Aceleración de la ejecución

Se pueden ejecutar, por ejemplo, un lote mientras otro hilo lee el lote siguiente de undispositivo.

11 HyperThreading (HT Technology) es una marca registrada de la empresa Intel para denominar suimplementación de la tecnología Multithreading Simultáneo también conocido como SMT. Permite alos programas preparados para ejecutar múltiples hilos (multi-threaded) procesarlos en paralelo dentro deun único procesador, incrementando el uso de las unidades de ejecución del procesador.

Esta tecnología consiste en simular dos procesadores lógicos dentro de un único procesador físico. Elresultado es una mejoría en el rendimiento del procesador, puesto que al simular dos procesadores sepueden aprovechar mejor las unidades de cálculo manteniéndolas ocupadas durante un porcentaje mayorde tiempo. Esto conlleva una mejora en la velocidad de las aplicaciones que según Intel esaproximadamente de un 30%.

La tecnología HyperThreading tiene grandes capacidades de procesamiento y rapidez. Algunas de susventajas son: mejora el apoyo de código “multi-hilos”, que permite ejecutar múltiples hilossimultáneamente, mejora de la reacción y el tiempo de respuesta.

De acuerdo con el primer informe de Intel, los Pentium 4 que incorporan esta tecnología tienen unrendimiento entre un 15% y un 30% superior al de los procesadores sin HyperThreading, y utilizan sóloun 5% más de recursos.

- Estructuración modular de los programas

Es un mecanismo eficiente para un programa que ejecuta una gran variedad deactividades separadas mediante hilos que realizan cada una de ellas.

Implementaciones

Hay dos grandes categorías en la implementación de hilos:

Hilos a nivel de usuario o ULT (user level thread). Hilos a nivel de kernel o KLT (kernel level thread).

Hilos a nivel de usuario (ULT)

En una aplicación ULT pura, todo el trabajo de gestión de hilos lo realiza la aplicacióny el núcleo o kernel no es consciente de la existencia de hilos. Es posible programar unaaplicación como multihilo mediante una biblioteca de hilos. La misma contiene elcódigo para crear y destruir hilos, intercambiar mensajes y datos entre hilos, paraplanificar la ejecución 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 mismoproceso. El kernel continua planificando el proceso como una unidad y asignándole unúnico estado (Listo, bloqueado, etc.).

Ventajas de los ULT

El intercambio de los hilos no necesitalos privilegios del modo kernel,porque todas las estructuras de datosestán en el espacio de direcciones deusuario de un mismo proceso. Por lotanto, el proceso no debe cambiar amodo kernel para gestionar hilos. Seevita la sobrecarga de cambio de modoy con esto el sobrecoste u overhead.

Se puede realizar una planificaciónespecífica. Dependiendo de queaplicación sea, se puede decidir poruna u otra planificación según sus ventajas.

Los ULT pueden ejecutar en cualquier sistema operativo. La biblioteca de hiloses un conjunto compartido.

Desventajas de los ULT

En la mayoría de los sistemas operativos las llamadas al sistema (System calls)son bloqueantes. Cuando un hilo realiza una llamada al sistema, se bloquea elmismo y también el resto de los hilos del proceso.

En una estrategia ULT pura, una aplicación multihilo no puede aprovechar lasventajas de los multiprocesadores. El núcleo asigna un solo proceso a un solo

procesador, ya que como el núcleo no interviene, ve al conjunto de hilos comoun solo proceso.

Una solución al bloqueo mediante a llamadas al sistema es usando la técnica dejacketing, que es convertir una llamada bloqueante en no bloqueante.

Hilos a nivel de núcleo (KLT)

En una aplicación KLT pura, todo el trabajo degestión de hilos lo realiza el kernel. En el área de laaplicación no hay código de gestión de hilos,únicamente un API (interfaz de programas deaplicación) para la gestión de hilos en el núcleo.Windows 2000, Linux y OS/2 utilizan este método.Linux utiliza un método muy particular en el queno hace diferencia entre procesos e hilos. ParaLinux, si varios procesos creados con la llamada alsistema "clone" comparten el mismo espacio dedirecciones virtuales, el sistema operativo los tratacomo hilos, y lógicamente son manejados por elkernel.

Ventajas de los KLT

El kernel puede planificar simultáneamente múltiples hilos del mismo procesoen múltiples procesadores.

Si se bloquea un hilo, puede planificar otro del mismo proceso. Las propias funciones del kernel pueden ser multihilo

Desventajas de los KLT

El paso de control de un hilo a otro precisa de un cambio de modo.

Combinaciones ULT y KLT

Algunos sistemas operativos ofrecen la combinación de ULT y KLT, como Solaris.

La creación de hilos, así como la mayor parte de la planificación y sincronización de loshilos de una aplicación se realiza por completo en el espacio de usuario. Los múltiplesULT de una sola aplicación se asocian con varios KLT. El programador puede ajustar elnúmero de KLT para cada aplicación y máquina para obtener el mejor resultado global.

En un método combinado, los múltiples hilos de una aplicación se pueden ejecutar enparalelo en múltiples procesadores y las llamadas al sistema bloqueadoras no necesitanbloquear todo el proceso.

Aspectos del Diseño de un Paquete de Hilos12

Un conjunto de primitivas relacionadas con los hilos (ej.: llamadas a biblioteca)disponibles para los usuarios se llama un “paquete de hilos” [25, Tanenbaum].

Respecto del manejo de los hilos se tienen hilos estáticos e hilos dinámicos.

En un diseño estático:

Se elige el número de hilos al escribir el programa o durante su compilación. Cada uno de ellos tiene asociada una pila fija. Se logra simplicidad pero también inflexibilidad.

En un diseño dinámico:

Se permite la creación y destrucción de los hilos durante la ejecución. La llamada para la creación de hilos determina:

o El programa principal del hilo.o Un tamaño de pila.o Una prioridad de planificación, etc.

La llamada generalmente regresa un identificador de hilo:o Se usará en las posteriores llamadas relacionadas al hilo.

Un proceso:o Se inicia con un solo hilo.o Puede crear el número necesario de hilos.

Los hilos pueden concluir:

Por su cuenta, al terminar su trabajo. Por su eliminación desde el exterior.

Los hilos comparten una memoria común:

Contiene datos que los distintos hilos comparten. El acceso generalmente se controla mediante regiones críticas.

Implantación de un Paquete de Hilos13

Un paquete de hilos se puede implantar en el espacio [25, Tanenbaum]:

Del usuario. Del núcleo.

Implantación del paquete de hilos en el espacio del usuario:

12 Fuente de consulta. Procesos y procesadores en sistemas distribuidos.http://exa.unne.edu.ar/depar/areas/informatica/SistemasOperativos/SOF.htm [On line] Consultado el 12de agosto de 2012.

13 Ibid.

El núcleo no sabe de su existencia. El núcleo maneja procesos con un único hilo. No requiere soporte de hilos por parte del S. O. Los hilos se ejecutan en un sistema de tiempo de ejecución:

o Es un grupo de procedimientos que manejan los hilos. Cuando un hilo ejecuta una llamada al sistema o cualquier acción que pueda

provocar su suspensión:o Llama a un procedimiento del sistema de tiempo de ejecución.o El procedimiento verifica si hay que suspender al hilo, en cuyo caso:

Almacena los registros del hilo en una tabla. Busca un hilo no bloqueado para ejecutarlo. Vuelve a cargar los registros de la máquina con los valores

resguardados del nuevo hilo. Las principales ventajas son:

o El intercambio de hilos es más rápido que si se utilizaran losseñalamientos al núcleo.

o Cada proceso puede tener su propio algoritmo adaptado de planificaciónde hilos.

o Tienen una mejor escalabilidad para un número muy grande de hilos, yaque no afectan al núcleo con tablas y bloques de control (pila).

Implantación del paquete de hilos en el espacio del núcleo:

No se necesita un sistema de tiempo de ejecución. Para cada proceso el núcleo tiene una tabla con una entrada por cada hilo que

contiene:o Los registros, estados, prioridades y demás información relativa al hilo.

Todas las llamadas que pueden bloquear un hilo se implantan como llamadas alsistema:

o Significa un costo mayor (en recursos y tiempo). Cuando un hilo se bloquea, el núcleo puede ejecutar:

o Otro hilo listo del mismo proceso.o Un hilo de otro proceso:

Con los hilos a nivel usuario el sistema de tiempo de ejecuciónmantiene en ejecución los hilos de su propio proceso hasta que: El núcleo les retira la CPU, o. No hay hilos listos.

Un problema fundamental de los paquetes de hilos a nivel usuario es el de las llamadasal sistema con bloqueo:

No se puede permitir que el hilo realmente realice la llamada al sistema:o Detendría a todos los hilos del proceso.o Un hilo bloqueado no debe afectar a los demás.

Una solución es agregar código junto a la llamada al sistema para verificar si lamisma no generaría bloqueo:

o Se efectuaría la llamada al sistema solo si la verificación da o.k.o El código adicional suele llamarse jacket.

Otro problema de los paquetes de hilos a nivel usuario es que si un hilo comienza suejecución no puede ejecutarse ningún otro hilo de ese proceso, salvo que el hiloentregue voluntariamente la CPU.

Un problema adicional para los hilos a nivel usuario es que generalmente losprogramadores desean los hilos en aplicaciones donde los hilos se bloquean a menudo:

Ej.: servidor de archivos con varios hilos.

Hilos y RPC14

Es común que los sistemas distribuidos utilicen RPC e hilos [25, Tanenbaum].

Al iniciar un hilo servidor, “S”, éste exporta su interfaz al informarle de ésta al núcleo;la interfaz define los procedimientos que puede llamar, sus parámetros, etc.

Al iniciar un hilo cliente, “C”, éste importa la interfaz del núcleo:

Se le proporciona un identificador especial para utilizarlo en la llamada. El núcleo sabe que “C” llamará posteriormente a “S”:

o Crea estructuras de datos especiales para prepararse para la llamada.

Una de las estructuras es una pila de argumentos compartida por “C” y “S”, que seasocia de manera lectura / escritura en ambos espacios de direcciones.

Para llamar al servidor, “C”:

Coloca sus argumentos en la pila compartida mediante el procedimiento normalde transferencia.

14 Ibídem.

Hace un señalamiento al núcleo colocando un identificador especial en unregistro.

El núcleo:

Detecta esto y deduce que es una llamada local. Modifica el mapa de memoria del cliente para colocar éste en el espacio de

direcciones del servidor. Inicia el hilo cliente, al ejecutar el procedimiento del servidor.

La llamada se efectúa de tal forma que:

Los argumentos se encuentran ya en su lugar:o No es necesario su copiado u ordenamiento.o La RPC local se puede realizar más rápido de esta manera.

Modelos de Sistemas

En un sistema distribuido, con varios procesadores, un aspecto fundamental del diseñoes cómo se los utiliza.

Los procesadores distribuidos se pueden organizar de varias formas:

Modelo de estación de trabajo. Modelo de la pila de procesadores. Modelo híbrido.

El Modelo de Estación de Trabajo15

El sistema consta de estaciones de trabajo (PC) dispersas conectadas entre sí medianteuna red de área local (LAN).

Pueden contar o no con disco rígido en cada una de ellas.

Los usuarios tienen:

Una cantidad fija de poder de cómputo exclusiva. Un alto grado de autonomía para asignar los recursos de su estación de trabajo.

Uso de los discos en las estaciones de trabajo:

Sin disco:o Bajo costo, fácil mantenimiento del hardware y del software, simetría y

flexibilidad.o Gran uso de la red, los servidores de archivos se pueden convertir en

cuellos de botella. Disco para paginación y archivos de tipo borrador:

o Reduce la carga de la red respecto del caso anterior.

15 Op. Cit.

o Alto costo debido al gran número de discos necesarios. Disco para paginación, archivos de tipo borrador y archivos binarios

(ejecutables):o Reduce aún más la carga sobre la red.o Alto costo y complejidad adicional para actualizar los binarios.

Disco para paginación, borrador, binarios y ocultamiento de archivos:o Reduce aún más la carga de red y de los servidores de archivos.o Alto costo.o Problemas de consistencia del caché.

Sistema local de archivos completo:o Escasa carga en la red.o Elimina la necesidad de los servidores de archivos.o Pérdida de transparencia.

Métodos

Lo que sigue es la lista de métodos importantes disponibles en la clase Thread.

SN Los métodos con Descripción

1 public void start ()inicia el hilo en un trazado independiente de la ejecución, a continuación, invoca el métodorun () en este objeto Thread.

2 public void run ()Si este objeto Thread se crea una instancia con un objetivo Ejecutable independiente, elmétodo run () se invoca en ese objeto Runnable.

3 setName public void final (String nombre)Cambia el nombre del objeto Thread. Hay también un método getName () para recuperar elnombre.

4 setPriority public void final (prioridad int)Establece la prioridad de este objeto Thread. Los valores posibles son entre 1 y 10.

5 public void setDaemon (boolean on)Un parámetro de verdad denota este Tema como un hilo demonio.

6 final void público, vaya (a largo milisegundos)El subproceso actual invoca este método en un subproceso en segundo lugar, haciendo que elhilo actual se bloquee hasta que el segundo hilo termina o pasa el número especificado demilisegundos.

7 interrupción public void ()interrumpe este hilo, causando que para continuar la ejecución si fue bloqueado por cualquiermotivo.

8 isAlive public final boolean ()Devuelve true si el hilo está vivo, que es cualquier momento después de que el hilo se hapuesto en marcha, pero antes de que se complete.

Los métodos anteriores se invocan en un objeto Thread en particular. Los siguientesmétodos de la clase Thread son estáticos. La invocación de uno de los métodos estáticoslleva a cabo la operación en el subproceso actualmente en ejecución.

SN Los métodos con Descripción

1 rendimiento public void ()Hace que el subproceso actualmente en ejecución para ceder el paso a cualquier otrosubproceso de la misma prioridad que están esperando para ser programado

2 sueño public void (largo milisegundos)hace que el subproceso actualmente en ejecución para bloquear por lo menos el númeroespecificado de milisegundos

3 public static boolean holdsLock (Object x)Devuelve true si el subproceso actual tiene el bloqueo en el objeto dado.

4 Tema currentThread pública estática ()Devuelve una referencia al subproceso actualmente en ejecución, que es el hilo que llama aeste método.

5 dumpstack public void ()Imprime el seguimiento de la pila para el subproceso actualmente en ejecución, lo cual es útilcuando se depura una aplicación multiproceso.

Ejemplos de multihilos

Ejemplo 1: Este es uno fácil

// Crear un Nuevo thread.class NewThread implements Runnable {

Thread t;NewThread() {

// Crear un Segundo threadt = new Thread(this, "Demo Thread");System.out.println("Child thread: " + t);t.start(); // Start the thread

}

// This is the entry point for the second thread.public void run() {

try {for(int i = 5; i > 0; i--) {

System.out.println("Child Thread: " + i);// Let the thread sleep for a while.Thread.sleep(500);

}} catch (InterruptedException e) {

System.out.println("Child interrupted.");}System.out.println("Exiting child thread.");

}}

class ThreadDemo {public static void main(String args[]) {

new NewThread(); // create a new threadtry {

for(int i = 5; i > 0; i--) {System.out.println("Main Thread: " + i);Thread.sleep(1000);


System.out.println("Main thread interrupted.");}System.out.println("Main thread exiting.");

}}

Que produce los siguientes resultados

Child thread: Thread[Demo Thread,5,main]Main Thread: 5Child Thread: 5Child Thread: 4

Main Thread: 4Child Thread: 3Child Thread: 2Main Thread: 3Child Thread: 1Exiting child thread.Main Thread: 2Main Thread: 1Main thread exiting.

Ejemplo 2.

Crear un thread extendido

// Crear un Segundo thread extendido de un Threadclass NewThread extends Thread {

NewThread() {// Create a new, second threadsuper("Demo Thread");System.out.println("Child thread: " + this);start(); // Start the thread

}

// This is the entry point for the second thread.public void run() {

try {for(int i = 5; i > 0; i--) {

System.out.println("Child Thread: " + i);// Let the thread sleep for a while.

Thread.sleep(500);}

} catch (InterruptedException e) {System.out.println("Child interrupted.");

}System.out.println("Exiting child thread.");

}}

class ExtendThread {public static void main(String args[]) {

new NewThread(); // create a new threadtry {

for(int i = 5; i > 0; i--) {System.out.println("Main Thread: " + i);Thread.sleep(1000);


System.out.println("Main thread interrupted.");}System.out.println("Main thread exiting.");

}}

El resultado que aparece es:

Child thread: Thread[Demo Thread,5,main]Main Thread: 5Child Thread: 5Child Thread: 4Main Thread: 4Child Thread: 3Child Thread: 2Main Thread: 3Child Thread: 1Exiting child thread.

Main Thread: 2Main Thread: 1Main thread exiting.

Ejemplo 3.

Sea una clase que produce datos y otra que los visualiza. La productora de datos sellama "tarea_datos" y la que los muestra se llama "tarea_vista". "tarea_vista" recibe unareferencia a "tarea_datos" para visualizar el resultado. Este ejemplo todavía no contienehilos, su comprensión ayudará a entender como funcionan los hilos en los siguientesejemplos. Para acercarnos a lo que será la explicación sobre hilos, cada clase realiza sulabor en la función run(). "tarea_datos" lee un número de un archivo y la "tarea_vista"lo muestra.

import java.io.*;/***************************************** Primera versión, sin hilos.* En un sólo hilo todo el procesamiento es secuencial y por tanto* realiza la operación correctamente, visualizando el dato****************************************/

public class control01 {public control01() {

tarea_datos01 t1 = new tarea_datos01();tarea_vista01 t2 = new tarea_vista01( t1 );t1.run(); // Lee datot2.run(); // Lo visualiza

}public static void main(String[] args) { control01 control1 =

new control01(); }}

/******************* Clase que obtiene el dato ******************/class tarea_datos01 {

private double resultado = -1;

public void run() { leer_datos(); }

void leer_datos() {try {

BufferedReader in = new BufferedReader( newFileReader("xxx") );

resultado = Double.parseDouble( in.readLine());

in.close();}catch (Exception e) { System.out.println(

e.getMessage() ); }}double obt_resultado() { return resultado; }

}

/****************** Clase visualizadora *******************/class tarea_vista01 {

private tarea_datos01 td;tarea_vista01( tarea_datos01 td ) { this.td = td; }public void run() { System.out.println( "Resultado: " +

td.obt_resultado() ); }}

Lo que hace la función main() es:

1. Crea un objeto t1 de la clase tarea_datos01.2. Crea un objeto t2 de la clase tarea_vista01, pasando como argumento el

objeto t1.3. La llamada a t1.run() obtiene el dato del archivo.4. La llamada a t2.run() implica:

I. Solicitar el dato a t1, llamando a t1.obt_resultado().II. Visualizar el resultado.

Entonces, tarea_vista es una clase excesivamente ligera o pequeña, esto solo porejemplo.

Puesto que el orden es secuencial y hay un único hilo (el hilo de ejecución de la funciónmain()), el resultado será el esperado: imprimir por pantalla el número leído del archivo.

¿Qué ocurre si no se cumple el orden secuencial y lógico de "I) obtener el dato y II)visualizarlo", sino que primero se visualiza y después se obtiene el resultado? Entonces,el resultado que se vería por pantalla sería incorrecto, es decir, el valor por defecto: -1.Esto es lo que nos ocurrirá en la siguiente versión.

Subclases de Thread

Ahora el programa anterior se pondrá en forma de multihilos, de tal forma que cadatarea sea un hilo. ¿Por qué usar hilos? Analice, por ejemplo, que puede interesarsimultanear la lectura de un fichero muy grande con otras tareas. Al fin y al cabo,estamos acostumbrados a esta simultaneidad mientras se navega por la web, donde a untiempo puede estar descargando un fichero y abriendo una página.

Algunas reglas:

1. Todo hilo se inicia con la función start(), no con su constructor.2. La función start() llama automáticamente a su función run(), sin intervención

del programador.3. La función run() debe reescribirse sin parámetros ni devolución de objetos.4. En la función run() el programador inserta las acciones específicas del hilo.5. No llames directamente al método run(), start() lo hace por ti. La llamada

directa a run() sólo ejecuta su contenido en el mismo hilo, y no en el nuevo quese ha iniciado.

En este caso se simula una situación típica para usar hilos: se necesita un flujo decontrol que produce los datos (por lectura y/o cálculo) y otro que los consume(visualización, etc.), pero no hay seguridad de que el consumo este sincronizado con laproducción. Al aplicar un esquema de programación multihilo vamos a enfrentarnos aalguno de los retos de la programación concurrente.

Entonces, los único que se ha hecho es heredar de la clase Thread y aplicar la regla 2, esdecir, llamamos a start() y esta función, predefinida por Java, llama automáticamentea run():

import java.io.*;/***************************************** Primera versión con hilos, que muestra el resultado incorrecto (-

1).* Ya que el hilo de visualización realiza su tarea antes de que* el hilo de datos termine de leer los datos. Para simular una

'larga'* lectura usamos sleep( milisegundos )****************************************/

public class control02 {public control02() {

tarea_datos02 t1 = new tarea_datos02();tarea_vista02 t2 = new tarea_vista02( t1 );t1.start(); // Lee datot2.start(); // Lo visualiza

}public static void main(String[] args) { control02 control1 =

new control02(); }}

/******************* Clase que obtiene dato ******************/class tarea_datos02 extends Thread {

private double resultado = -1;

public void run() { leer_datos(); }

void leer_datos() {try {


sleep( 1000 );resultado = Double.parseDouble( in.readLine()

);in.close();

}catch (Exception e) { System.out.println(

e.getMessage() );}}

double obt_resultado() { return resultado; }}

/****************** Clase visualizadora *******************/class tarea_vista02 extends Thread {

private tarea_datos02 td;tarea_vista02( tarea_datos02 td ) { this.td = td; }public void run() { System.out.println( "Resultado: " +

td.obt_resultado() ); }}

Con t1.start() se inicia el hilo que realiza la lectura. Paralelamente searranca t2 con t2.start(), que llama a t2.run() para visualizar el número. Lo que elprograma devuelve es:

Resultado: -1

Resulta evidente que se ha visualizado la variable antes de haber leído su valor delarchivo. Necesitamos sincronizar los hilos. Necesitamos que el hilo de visualización nose adelante al hilo de cálculo.

Los métodos sleep() e interrupt()

Esta es una primera aproximación a la sincronización de hilos, usando sleep(), que sirvepara decirle a un hilo que se duerma durante un periodo de tiempo (medido enmilisegundos). En nuestro ejemplo modificamos tarea_datos() para que devuelva elresultado más tarde (y correctamente), es decir, retrasamos un hilo para "dar tiempo" aotro para que termine su tarea:

double obt_resultado() {try {

sleep(1050); // Duermo un pocoreturn resultado; // Devuelvo el dato

}catch (InterruptedException e) {

System.out.println( e.getMessage() );return -1;

}}

sleep() exige el manejo de InterruptedException. Pero no es una solución muy elegante:¿el sueño debe durar 1 segundo?, ¿o tal vez un minuto? Por cierto, nuestra llamadainvoca al método de un objeto (this). Pero podemos usar sleep() como método de clase(ya que es static) en la forma:

Thread.sleep( 1050 );

Lo que estamos haciendo es dormir al hilo actual, dando así la posibilidad de más ciclosde procesamiento al resto de hilos.

La excepción InterruptedException se dispara cuando otro hilo llama a interrupt() delhilo que se quiere interrumpir. No suele usarse interrupt(), ya que los hilos sueleninterrumpirse cuando termina, llega al fin de run(). Con interrupt() despertamos a unhilo que se encuentra dormido o bloqueado, por ejemplo por una larga operación deentrada/salida, por wait() o por sleep(). Hay una excepción a la reglasobre InterruptedException: si se llama a interrupt() cuando el hilo no está durmiendo oesperando, no se genera InterruptedException. Puede saber si un hilo esta interrumpidopor medio de la función "boolean isInterrupted()":

if ( !isInterrupted() )...

Los métodos stop() y suspend() han sido desaconsejados por SUN.

Bloqueo de objetos (synchronized)

Uno de los problemas centrales de la programación multihilo es manejar situaciones enlas que más de un hilo tiene acceso a la misma estructura de datos, que es lo que sucedenormalmente en un sistema operativo. Por ejemplo, si un hilo estuviera intentandoactualizar los elementos de una lista, mientras otro está simultáneamente intentandoclasificarla, su programa puede bloquearse o producir resultados incorrectos. Para evitareste problema, debe utilizar la sincronización de hilos.

La forma más sencilla de evitar que dos objetos accedan a un método de un tercero almismo tiempo es que el primer hilo lo bloquee. Cuando un hilo mantiene un bloqueo,otro hilo que también lo necesita tiene que esperar hasta que el primer hilo liberasu bloqueo. ¿Cómo se hace? declarando métodos sincronizados (synchronized), porejemplo:

synchronized void leer_datos() { ... }

Una buena metáfora es pensar la situación de bloqueo como una puerta que tiene uncerrojo en su interior, cuando un hilo accede al método cierra la puerta y bloquea lapuerta, de tal forma que otro hilo que quiera acceder a la misma se debe mantener enespera hasta que el primero sale.

Para mantener un método libre de problemas con los hilos (thread-safe), se utiliza lapalabra clave synchronized. El hilo anula el bloqueo cuando sale del último métodosincronizado. En nuestro caso hemos hecho que dos métodos sean sincronizados:

synchronized void leer_datos() {try {


sleep( 1000 );resultado = Double.parseDouble( in.readLine()

);in.close();

}catch (IOException e) { System.out.println(

e.getMessage() ); }}

synchronized double obt_resultado() { return resultado; } //Hemos quitado sleep() de aqui

Funciona. Visualizamos el número que se tenía almacenado en el archivo. ¿Por qué? Elobjeto 'vista' no puede acceder a tarea_datos04.obt_resultado hasta que el objeto de'tarea_datos04' no ha sido desbloqueado.

Hay un malentendido habitual: creer que lo que se bloquea es el método. Es un errornatural, puesto que ponemos la palabra synchronized en un método tendemos a pensarque el bloqueo se produce sobre el método. Es decir: ES EL OBJETO EL QUE ESTABLOQUEADO, NO EL METODO. Para la JVM cada objeto tiene un contador de

bloqueo, que registra el número de métodos sincronizados que permanecen enejecución. Cuando el contador alcanza el valor de cero, se libera el bloqueo.

Métodos wait() y notify()

Se ha observado como se puede colocar secuencialmente los hilos por mediode synchronized. Los métodos wait() y notify() extienden o potencian esta capacidad.Estos métodos los hereda toda clase de Java, ya que están definidos en la clase Object.Sólo pueden usarse en métodos sincronizados.

Con wait() un hilo se queda en espera y libera el cerrojo sobre el objeto que hubiesebloqueado (recuerde aquí la metáfora de la puerta con cerrojo). Importante para evitaresperas "eternas" (y aplicaciones "colgadas") es tener en cuenta que cuando un hiloentra en espera no tiene posibilidad de despertarse sólo, sino que depende de otro hiloque lo despierte mediante notity(). Cuando no esté seguro de cual es el hilo que debedespertar lo más seguro es usar notifyAll(). Las aplicaciones obedecen a una serie dereglas:

Regla 1 (que es la synchronized): si varios hilos modifican un objeto, declare losmétodos modificadores, así como los de sólo lectura, como sincronizados. En elejemplo anterior:

synchronized void leer_datos() {BufferedReader in = new BufferedReader( new

FileReader("xxx") );....

}

synchronized double obt_resultado() { return resultado; }

Regla 2: cuando un hilo depende del estado de un objeto, debe esperar dentro del objeto(no fuera), en un método sincronizado en el que llama a wait(). Un esquema:

synchronized tipo obtener_dato() {notifyAll(); // Despierto a los demáswhile ( !condicion ) // Mientras no se cumplan

prerrequisitos para conseguir datowait(); // Espero

return dato; // Hago mi trabajo}

Regla 3: cuando un hilo cambia el estado de un objeto llama a notifyAll(), ya que de estaforma da oportunidad a los demás para despertar y comprobar si el cambio les afecta.Un esquema:

synchronized tipo modificar_dato() {while ( !condicion ) // Mientras no se cumplan

prerrequisitos para hacer mi trabajowait(); // Espero

... modifico datos ... // Hago mi trabajonotifyAll(); // Despierto a los demás

}

Regla 4: el método run() suele tener la forma siguiente (ver Horstmann y Cornell ,2003,p. 62-63):

public void run() {try {

while ( !interrupted() ) {... hago mi trabajo ...sleep( x );

}}catch (InterruptedException e) { }

}

El método interrupted() es estático y comprueba si el hilo actual ha sido interrumpido.Además su llamada reinicia el estado de "interrumpido" del hilo. A diferenciade isInterrupted() que hace la comprobación pero no modifica el estado "interrumpido"del hilo.

Ver un buen ejemplo de wait() y notify() en Niemeyer y Knudsen (2000, pag. 257).

Ejemplo 4.

Este es un ejemplo que se ha adaptado de Horstmann y Cornell (2003, p. 13-17). Eneste caso no se usa Swing, sino AWT (se usa la clase Applet, en vez de JFrame).Además, a diferencia del original, las bolas no salen de la misma posición y suvelocidad varía.

El applet no tiene una complejidad especial:

/***********************************************************************Al presionar el botón Iniciar, se crea y arranca un hiloCada hilo mueve una bola

************************************************************************/public class animacion_bolas extends Applet {

int origen_x = 0;private panel_bolas pbola = new panel_bolas();private Panel pbotones = new Panel();Button b_iniciar = new Button( "Iniciar"); // Boton para

iniciar una animación

/******* Inicializar el applet ********/public void init() {

try {jbInit();

}catch(Exception e) { e.printStackTrace(); }

}

/**************Inicialización de componentes ***********/private void jbInit() throws Exception {

this.setLayout( new BorderLayout() );

pbola.setBackground(Color.cyan);b_iniciar.addActionListener(new

animacion_bolas_b_iniciar_actionAdapter(this));pbotones.add( b_iniciar );add(pbola, BorderLayout.CENTER);add(pbotones, BorderLayout.SOUTH);

}

/**** Crea la bola: (1) se la pasa al panel y (2) se la pasa alhilo, después start */

public void aniadir_bola() {origen_x += 10;if ( origen_x > 150 )

origen_x = 0;bola b = new bola( pbola, origen_x, 0 );pbola.add(b); // Añadir

bola a panelhilo_de_bola thread = new hilo_de_bola( b, origen_x/5

);thread.start();

}

/**** Gestiona el evento de pulsar botón: añade bola ****/void b_iniciar_actionPerformed(ActionEvent e) {

aniadir_bola();}

}

Lo único relevante es ver que al pulsar el botón se llama a la función "aniadir_bola()".En esta función se crea la bola (pasándole al constructor el panel de bolas y lascoordenadas de su origen. A continuación se crea el hilo (se le pasa la bola y el periodode refresco medido en milisegundos). Por último, se inicia el hilo con thread.start();

El panel de bolas lleva el registro (Vector) de las bolas creadas y pinta las bolas enrespuesta al evento paint:

class panel_bolas extends Panel {private Vector lista_bolas = new Vector();

public void add( bola b ) { lista_bolas.add(b); }

public void paint(Graphics g) {Graphics2D g2 = (Graphics2D)g;for (int i = 0; i < lista_bolas.size(); i++) {

bola b = (bola)lista_bolas.get(i);b.draw(g2);

}}

}

Lo interesante es ver lo que ocurre cuando se ejecuta con start() el hilo: mueve cadaperiodo de "milisegundos" la bola. Para determinar la velocidad usamos sleep().Con sleep() no sólo se consigue que duerma el hilo, sino que además se tiene un hilobien diseñado, ya que al dormir permite que otros hilos hagan su trabajo.

class hilo_de_bola extends Thread {

private bola b;private int milisegundos;public hilo_de_bola( bola abola, int milisegundos ) {

b = abola;this.milisegundos = milisegundos;

}

public void run() {try {

for (int i = 1; i < = 1000; i++) {b.move(); //

Ordeno al objeto que se muevasleep( milisegundos ); //

Duerme al hilo}

}catch (InterruptedException e) { System.out.println(

e.getMessage() ); }}

}

La clase bola es responsable de mover la posición de la bola y dibujarla:

class bola {private panel_bolas pbolas;private static final int XSIZE = 15;private static final int YSIZE = 15;private int x = 0;private int y = 0;private int dx = 2; // Salto en la Xprivate int dy = 2; // Salto en la Y

/***** Construye la bola, asociada a un panel y unascoordenadas de origen ******/

public bola(panel_bolas c, int origen_x, int origen_y ) {pbolas = c;x = origen_x;y = origen_y;

}

/** Dibuja la bola en su posición actual ******/public void draw(Graphics2D g2) {

g2.fill(new Ellipse2D.Double(x, y, XSIZE, YSIZE));}

/***** Cambio la posición de la bola y ordeno repintar *****/public void move() {

/*** Incremento x,y ***/x += dx;y += dy;

/**** Si llega al limite inferior o superior de x,invierte el movimiento */

if (x < 0) {x = 0;dx = -dx;

}if (x + XSIZE >= pbolas.getWidth()) {

x = pbolas.getWidth() - XSIZE;dx = -dx;

}/**** Si llega al limite inferior o superior de y,

invierte el movimiento */if (y < 0) {

y = 0;dy = -dy;

}if (y + YSIZE >= pbolas.getHeight()) {

y = pbolas.getHeight() - YSIZE;dy = -dy;

}

pbolas.repaint(); // Repintar el panel}

}

/**** Gestión de evento de botón ******/class animacion_bolas_b_iniciar_actionAdapter implementsjava.awt.event.ActionListener {

animacion_bolas adaptee;

animacion_bolas_b_iniciar_actionAdapter(animacion_bolasadaptee) {

this.adaptee = adaptee;}public void actionPerformed(ActionEvent e) {

adaptee.b_iniciar_actionPerformed(e);}

}

El interfaz Runnable

En ocasiones puede interesar que una clase que hereda de otra (por ejemplo de Applet)al mismo tiempo contenga el método run() propio de un Thread. Pero en Java, adiferencia de C++, no hay herencia múltiple; en esta situación una solución típica deJava es combinar la herencia (extends) con la recepción (implements) de un interfaz. Ennuestro ejemplo ocurre que la clase hereda (extends) de Applet y reciba un interfaz quele permita contener el método deseado, run(). Para ello usamos "implements Runnable".En el siguiente ejemplo se tiene un applet que funciona como un reloj: cada segundo semuestra por pantalla la hora:

public class reloj extends Applet implements Runnable {

private Thread hilo;int periodo_refresco = 1000;

/************************************************************************

* run del hilo: se duerme durante un segundo***************************************************************

********/public void run() {

while ( hilo != null ) {try {

Thread.sleep( periodo_refresco );}catch (InterruptedException e ) { return; }repaint();

}}

public void paint( java.awt.Graphics g ) {g.drawString( new java.util.Date().toString( ), 10, 25

);}

/***********************************************************************

* No confundirse: este método es el start del applet.* Desde aquí llamamos a start del hilo.***************************************************************

********/public void start( ) {

if ( hilo == null ) {hilo = new Thread(this); // Coloco applet en

hilohilo.start();

}}

/***********************************************************************

* Parada del applet: si la referencia al hilo no es nula: paroel hilo.

***********************************************************************/

public void stop( ) {if ( hilo != null ) {

hilo.interrupt();hilo = null;

}}

}

Esto produciría siguiente resultado:

Aspectos de la solución:

1. El hilo es un atributo del applet. Su variable sirve como señal de control: cuandoes null significa que el hilo está parado (además facilita la recolección debasura).

2. Con start() creamos el hilo (pasamos una referencia del applet, this, alconstructor del hilo). A continuación iniciamos el hilo, por medio de lallamada hilo.start(). No debemos confundir el método start() del applet con elmétodo start() del hilo.

3. El método run() implementa la tarea que se desea: duerme durante un segundo yllama a repaint().

4. Cuando el applet se detiene (stop), se interrumpe el hilo. Cuando se vuelva ainiciar el applet (start) se vuelve a crear e iniciar el hilo.

Uso de Estaciones de Trabajo Inactivas16

La idea consiste en ordenarremotamente la ejecución de procesosen estaciones de trabajo inactivas.

Los aspectos clave son:

¿Cómo encontrar una estaciónde trabajo inactiva?

¿Cómo lograr que un procesoremoto se ejecute deforma transparente?

¿Qué ocurre si regresa elposeedor de la máquina?

Generalmente se considera que una estación de trabajo está “inactiva” cuando se danambas condiciones:

Nadie toca el ratón o el teclado durante varios minutos. No se ejecuta algún proceso iniciado por el usuario.

Los algoritmos para localizar las estaciones de trabajo inactivas se pueden dividir endos categorías:

Controlados por el servidor. Controlados por el cliente.

Algoritmos controlados por el servidor:

Cuando una estación de trabajo está inactiva:o Se convierte en un servidor potencial.o Anuncia su disponibilidad:

Proporciona su nombre, dirección en la red y propiedades: Grabándolos en un archivo, o. Transmitiéndolos a las otras estaciones.

Se pueden dar situaciones de competencia entre distintos usuarios para accedera la misma estación inactiva al mismo tiempo:

o Se deben detectar al ingresar el requerimiento.o Solo progresa el primer requerimiento arribado.o Se elimina a la estación de la lista de inactivas.o Quien hizo el llamado puede enviar su ambiente e iniciar el proceso

remoto.

Algoritmos controlados por el cliente:

16 A. S. Tanenbaum. Sistemas Operativos Distribuidos. Prentice Hall Hispanoamericana, S.A., México,1996.

El cliente transmite una solicitud indicando el programa que desea ejecutar, lacantidad de memoria necesaria, si requiere un chip coprocesador, etc.

Al regresar la respuesta se elige una estación y se la configura.

Para ejecutar el proceso en la estación remota seleccionada se debe lograr:

El desplazamiento del código. La configuración del proceso remoto de modo que:

o “Vea” el mismo ambiente que tendría en el caso local, en la estación detrabajo de origen.

o Ejecute de la misma forma que en el caso local.

Se necesita la misma visión del sistema de archivos, el mismo directorio de trabajo, etc.Si se trabaja sobre el servidor de archivos seenvían las solicitudes de disco al servidor.

Si se trabaja con discos locales se envían lassolicitudes a la máquina de origen para suejecución.

Ciertas operaciones como la lectura del tecladoy la escritura en la pantalla:

Nunca se pueden ejecutar en lamáquina remota.

Deben regresar a la máquina de origen.

Todas las llamadas al sistema que soliciten el estado de la máquina deben realizarse enla máquina donde se ejecuta el proceso.

Las llamadas al sistema relacionadas con el tiempo son un serio problema debido a lasdificultades de sincronización.

En caso de que regrese el poseedor de la máquina:

Se podría no hacer nada, contra la idea de estaciones de trabajo “personales”. Se podría eliminar el proceso intruso:

o Abruptamente, perdiéndose el trabajo hecho y generando caos en elsistema de archivos.

o Ordenadamente, salvando el procesamiento ya hecho y preservando laintegridad del sistema de archivos.

Se podría emigrar el proceso a otra estación.

El Modelo de la Pila de Procesadores17

Se dispone de un conjunto de CPU que se pueden asignar dinámicamente a los usuariossegún la demanda.

17 Ibid.

Los usuarios no disponen de estaciones de trabajo sino de terminales gráficas de altorendimiento.

No existe el concepto de propiedad de los procesadores, los que pertenecen a todos y seutilizan compartidamente.

El principal argumento para la centralización del poder de cómputo como una pila deprocesadores proviene de la teoría de colas:

Llamamos “l” a la tasa de entradas totales de solicitudes por segundo de todoslos usuarios combinados.

Llamamos “m” a la tasa de procesamiento de solicitudes por parte del servidor. Para una operación estable debe darse que “m >l”:

o Se pueden permitir pequeños lapsos de tiempo en los que la tasa deentrada exceda a la de servicio.

Llamamos “T” al promedio de tiempo entre la emisión de una solicitud y laobtención de una respuesta completa:

o T = 1 / ( m - l ).o Cuando “l ” tiende a “0”, “T” no tiende a “0”.

Supongamos que tenemos “n” multiprocesadores personales, cada uno concierto número de CPU y con su propio sistema de colas con tasas “l ” y “ m ” ytiempo “T”:

o Si reunimos todas las CPU y formamos una sola pila deprocesadores tendremos un solo sistema de colas en vez de “n” colasejecutándose en paralelo.

o La tasa de entrada será “n l”, la tasa de servicio será “n m” y el tiempopromedio de respuesta será: T1 = 1 / (n m - n l) = 1 / n (m - l) = T / n.

o Conclusión: si reemplazamos “n” pequeños recursos por uno grandeque sea “n” veces más poderoso: Podemos reducir el tiempo promedio de respuesta “n” veces.

El modelo de pila es más eficiente que el modelo de búsqueda de estaciones inactivas.

También existe el modelo híbrido que consta de estaciones de trabajo y una pila deprocesadores.

Asignación de Procesadores

Son necesarios algoritmos para decidir cuálproceso hay que ejecutar y en qué máquina.

Para el modelo de estaciones de trabajo:

Decidir cuándo ejecutar el procesode manera local y cuándo buscar unaestación inactiva.

Para el modelo de la pila de procesadores:

Decidir dónde ejecutar cada nuevo proceso.

Modelos de Asignación

Generalmente se utilizan las siguientes hipótesis:

Todas las máquinas son idénticas (o al menos compatibles en el código);difieren a lo sumo en la velocidad.

Cada procesador se puede comunicar con los demás.

Las estrategias de asignación de procesadores se dividen en:

No migratorias:o Una vez colocado un proceso en una máquina permanece ahí hasta que

termina. Migratorias:

o Un proceso se puede trasladar aunque haya iniciado su ejecución.o Permiten un mejor balance de la carga pero son más complejas.

Los algoritmos de asignación intentan optimizar algo:

Uso de las CPU:o Maximizar el número de ciclos de CPU que se ejecutan para trabajos de

los usuarios.o Minimizar el tiempo de inactividad de las CPU.

Tiempo promedio de respuesta:o Minimizar no los tiempos individuales de respuesta sino los tiempos

promedio de respuesta. Tasa de respuesta:

o Minimizar la tasa de respuesta, que es el tiempo necesario para ejecutarun proceso en cierta máquina dividido por el tiempo que tardaría encierto procesador de referencia.

Aspectos del Diseño de Algoritmos de Asignación de Procesadores18

Los principales aspectos son los siguientes:

Algoritmos deterministas vs. heurísticos. Algoritmos centralizados vs. distribuidos. Algoritmos óptimos vs. subóptimos. Algoritmos locales vs. globales. Algoritmos iniciados por el emisor vs. iniciados por el receptor.

Los algoritmos deterministas son adecuados cuando se sabe anticipadamente todoacerca del comportamiento de los procesos, pero esto generalmente no se da, aunquepuede haber en ciertos casos aproximaciones estadísticas.

Los algoritmos heurísticos son adecuados cuando la carga es impredecible.

18 Ibídem.

Los diseños centralizados permiten reunir toda la información en un lugar y tomar unamejor decisión; la desventaja es que la máquina central se puede sobrecargar y se pierderobustez ante su posible falla.

Generalmente los algoritmos óptimosconsumen más recursos quelos subóptimos, además, en la mayoríade los sistemas reales se buscansoluciones subóptimas, heurísticas ydistribuidas.

Cuando se va a crear un proceso se debedecidir si se ejecutará en la máquina quelo genera o en otra (política detransferencia):

La decisión se puede tomar “solocon información local” o “con información global”.

Los algoritmos locales son sencillos pero no óptimos. Los algoritmos globales son mejores pero consumen muchos recursos.

Cuando una máquina se deshace de un proceso la política de localización debe decidirdónde enviarlo:

Necesita información de la carga en todas partes, obteniéndola de:o Un emisor sobrecargado que busca una máquina inactiva.o Un receptor desocupado que busca trabajo.

Aspectos de la Implantación de Algoritmos de Asignación de Procesadores

Casi todos los algoritmos suponen que las máquinas conocen su propia carga y quepueden informar su estado:

La medición de la carga no es tan sencilla. Un método consiste en contar el número de procesos (hay que considerar los

procesos latentes no activos). Otro método consiste en contar solo los procesos en ejecución o listos. También se puede medir la fracción de tiempo que la CPU está ocupada.

Otro aspecto importante es el costo excesivo en consumo de recursos para recolectarmedidas y desplazar procesos, ya que se debería considerar el tiempo de CPU, el uso dememoria y el ancho de banda de la red utilizada por el algoritmo para asignación deprocesadores.

Se debe considerar la complejidad del software en cuestión y sus implicancias para eldesempeño, la correctez y la robustez del sistema.

Si el uso de un algoritmo sencillo proporciona casi la misma ganancia que uno más caroy más complejo, generalmente será mejor utilizar el más sencillo.

Se debe otorgar gran importancia a la estabilidad del sistema:

Las máquinas ejecutan susalgoritmos en forma asíncrona porlo que el sistema nunca seequilibra.

La mayoría de los algoritmos queintercambian información:

o Son correctos luego deintercambiar la informacióny de que todo se haregistrado.

o Son poco confiablesmientras las tablascontinúan su actualización,es decir que se presentansituaciones de no equilibrio.

Ejemplos de Algoritmos de Asignación de Procesadores19

Un Algoritmo Determinista Según la Teoría de Gráficas

Es aplicable a sistemas donde se conoce:

Requerimientos de CPU y de memoria de los procesos. Tráfico promedio entre cada par de procesos.

Si el número de procesos supera al número de CPU:

Habrá que asignar varios procesos a la misma CPU. La asignación deberá minimizar el tráfico en la red.

El sistema se puede representar en una gráfica con pesos:

Cada nodo es un proceso. Cada arco es el flujo de mensajes entre dos procesos.

El problema es encontrar la forma de partir la gráfica en subgráficas sujetas arestricciones (ej.: CPU y de memoria) (ver Figura 10.1 y Figura 10.220 ):

Los arcos que van de una subgráfica a la otra representan el tráfico en la red. Cada subgráfica es una unidad de asignación. El algoritmo debe buscar unidades de asignación fuertemente acopladas:

o Tráfico intenso dentro de la unidad de asignación.o Tráfico escaso entre unidades de asignación.

19 A. S. Tanenbaum. Sistemas Operativos Modernos. Prentice Hall Hispanoamericana, S.A., México,1993.20 Ibid.

Figura. Una forma de asignar 9 procesos a 3 procesadores

Figura. Otra forma de asignar 9 procesos a 3 procesadores

Un Algoritmo Centralizado

Es un algoritmo heurístico que a diferencia del anterior no precisa informaciónanticipadamente.

Es un algoritmo arriba-abajo (Mutka y Livny) centralizado porqueun coordinador mantiene una tabla de usos:

Contiene una entrada por estación de trabajo inicializada en “0”. Cuando ocurren eventos significativos se envían al coordinador mensajes para

actualizar la tabla. Las decisiones de asignación se basan en la tabla:

o Se toman cuando ocurren eventos de planificación, tales como: se realizauna solicitud, se libera un procesador, el reloj produce una marca detiempo.

No se intenta maximizar el uso de la CPU. Se procura otorgar a cada usuario una parte justa del poder de cómputo. Cuando la máquina donde se crea un proceso decide que se debe ejecutar en otra

parte:o Le pide al coordinador de la tabla de usos que le asigne un procesador:

Si existe uno disponible y nadie más lo desea, se otorga elpermiso.

Si no, la solicitud se niega y se registra. Si un usuario ejecuta procesos en máquinas de otros usuarios acumula puntos de

penalización por segundo, lo que se registra en la tabla de usos.

Si un usuario tiene solicitudes pendientes insatisfechas, se restan puntos depenalización.

Si no existen solicitudes pendientes y ningún procesador está en uso, la entradade la tabla de usos se desplaza un cierto número de puntos hacia el “0”, hastaalcanzarlo.

El movimiento de puntos hacia arriba y abajo da nombre al algoritmo.

Un puntaje positivo en una entrada de la tabla de usos indica que la estación detrabajo relacionada es un usuario de los recursos del sistema.

Un puntaje negativo significa que precisa recursos.

Una puntuación “0” es neutra.

La heurística utilizada para la asignación de procesadores es la siguiente:

Cuando un procesador se libera gana la solicitud pendiente cuyo poseedor tienela puntuación menor.

Un usuario que no ocupe procesadores y que tenga pendiente una solicituddurante mucho tiempo:

o Siempre vencerá a alguien que utilice muchos procesadores.o Se cumple con el principio de asignar la capacidad de manera justa.

Un Algoritmo Jerárquico21

El algoritmo anterior no se adapta bien a los sistemas de gran tamaño, pues el nodocentral se convierte en un cuello de botella y en un único punto de fallo.

Una solución son los algoritmos jerárquicos que:

Mantienen la sencillez de los centralizados. Se escalan mejor que los centralizados.

Un método consiste en organizar a los procesadores en jerarquíaslógicas independientes de la estructura física:

Se establece un árbol jerárquico con distintos niveles. Para cada grupo de máquinas hay una máquina administradora:

o Mantiene un registro de las máquinas ocupadas y las inactivas. Cada procesador se comunica con un superior y un número reducido de

subordinados:o El flujo de información es controlable.

En caso de falla de un equipo con funciones jerárquicas:

Lo puede reemplazar un subordinado:

21 A. S. Tanenbaum. Operating Systems: Design And Implementation. Prentice Hall, NJ-USA, 1987.

o La elección la pueden hacer los subordinados, los pares jerárquicos delequipo fallado o el superior jerárquico del mismo.

Para disminuir la vulnerabilidad se puede tener en la cima del árbol jerárquico no unosino un grupo de equipos; si alguno del grupo falla los restantes eligen a un subordinadopara integrar el grupo superior.

Las tareas se pueden crear en cualquier partede la jerarquía y pueden requerir variosprocesos, es decir varios procesadores.

Cada administrador debe mantenerun registro de sus equipos dependientes queestén disponibles.

Si el administrador que recibe una solicituddetermina que no tiene suficientesprocesadores disponibles, transfiere lasolicitud hacia arriba a su superior, quientambién podría trasladarla hacia arribanuevamente.

Si el administrador determina que sí puede satisfacer la solicitud:

Divide la solicitud en partes y la distribuye a los administradores subordinados aél.

Los subordinados repiten esta operación hasta llegar al nivel inferior. Los procesadores se señalan como “ocupados” y el número de procesadores

asignados se informa hacia arriba.

Un importante problema consiste en que podría haber varias solicitudes en distintasetapas del algoritmo de asignación:

Puede conducir a estimaciones no actualizadas del número de procesadoresdisponibles (también pudieron salir de servicio algunos de los consideradosdisponibles).

Podrían presentarse situaciones de competencia, bloqueo, etc. en el intento deasignación de procesadores.

Un Algoritmo Distribuido Heurístico (Eager)

Al crearse un proceso.

La máquina donde se origina envía mensajes de prueba a una máquina elegida alazar; pregunta si su carga está por debajo de cierto valor de referencia.

Si la respuesta es positiva el proceso se envía a ese lugar. Si no, se elige otra máquina para la prueba. Luego de “n” pruebas negativas el algoritmo termina y el proceso se ejecuta en

la máquina de origen.

Un Algoritmo de Remates22

Utiliza un modelo económico con:

Compradores y vendedores de servicios. Precios establecidos por la oferta y la demanda.

Los procesos deben comprar tiempo de CPU.

Cada procesador anuncia su precio mediante un archivo que todos pueden leer (es elprecio pagado por el último cliente).

Los distintos procesadores pueden tener distintos precios según sus características yservicios.

Cuando un proceso desea iniciar un proceso hijo:

Verifica si alguien ofrece el servicio que necesita. Determina el conjunto de procesadores que pueden prestar sus servicios. Selecciona el mejor candidato según precio, rapidez, relación precio /

desempeño, tipo de aplicación, etc. Genera una oferta y la envía a su primera opción.

Los procesadores:

Reúnen las ofertas recibidas y eligen una. Informan a los ganadores y perdedores. Ejecutan los procesos. Actualizan los precios.

Planificación en Sistemas Distribuidos23

Generalmente cada procesador hace su planificación local (si tiene varios procesos enejecución) independientemente de lo que hacen los otros procesadores.

La planificación independiente no es eficiente cuando se ejecutan en distintosprocesadores un grupo de procesos:

Relacionados entre sí. Con una gran interacción entre los procesos.

Se necesita una forma de garantizar que los procesos con comunicación frecuente seejecuten de manera simultánea.

En muchos casos un grupo de procesos relacionados entre sí iniciarán juntos.

22 A. S. Tanenbaum. Redes de Computadoras. Prentice Hall Hispanoamericana S. A., México, 1997.23 Ibid.

La comunicación dentro de los grupos debe prevalecer sobre la comunicación entre losgrupos.

Se debe disponer de un número deprocesadores suficiente parasoportar al grupo de mayor tamaño.

Cada procesador semultiprograma con “n” espaciospara los procesos(multiprogramación de nivel “n”).

El algoritmo de Ousterhout utilizael concepto de coplanificación:

Toma en cuenta los patrones de comunicación entre los procesos durante laplanificación.

Debe garantizar que todos los miembros del grupo se ejecuten al mismo tiempo. Se emplea una matriz conceptual donde:

o Las filas son espacios de tiempo.o Las columnas son las tablas de procesos de los procesadores.

Cada procesador debe utilizar un algoritmo de planificación Round Robin:o Todos los procesadores ejecutan el proceso en el espacio “0” durante un

cierto período fijo.o Todos los procesadores ejecutan el proceso en el espacio “1” durante un

cierto período fijo, etc. Se deben mantener sincronizados los intervalos de tiempo. Todos los miembros de un grupo se deben colocar en el mismo número de

espacio de tiempo pero en procesadores distintos.

Ejemplo de algoritmo24

El programa en Java desarrollado se encuentra en el archivo Hilos.java y posee lassiguientes características:

Se lo puede invocar mediante “java Hilos” y recibe como entradas por pantallalos datos de configuración de la simulación referidos a:

Número inicial de buffers ocupados. Número máximo de buffers leidos por vez. Número mínimo de buffers ocupados antes de grabar más. Número de buffers grabados por vez. Número de milisegundos de la ejecución.

Respecto del archivo generado, el mismo tendrá un tamaño variable según los datos quese hayan suministrado a la ejecución que lo produce, especialmente el tiempo de

24 Fuente de consulta. Concurrencia e hilos.http://exa.unne.edu.ar/depar/areas/informatica/SistemasOperativos/SOF.htm [On line] Consultado el 12de agosto de 2012.

ejecución; es preciso señalar además que el archivo es reutilizable, es decir que se borraautomáticamente al iniciar cada ejecución.

El código del programa desarrollado (Hilos.java) es el siguiente:

// Trabajo práctico parte de la Tesis de la Maestría en Informática y// Computación - 2000. David Luis la Red Martínez.//// Ejemplo de concurrencia e hilos con JAVA.//// El ejemplo contempla el problema de productores / consumidores:// * Los hilos productores graban (y ocupan) buffers en un pool de buffers disponibles.// * Los hilos consumidores leen (y liberan) buffers del pool de buffers disponibles.//import java.io.*;import java.util.*;import java.util.Date;import java.awt.*;import java.awt.event.*;import java.awt.image.*;import java.applet.*;import java.applet.Applet;import java.math.*;import java.text.*;import java.lang.String;import java.lang.*;public class Hilos extends Frameimplements ActionListener {VentanaDialogCH ventana;SimpleDialogCH dialog;TextArea textArea;Button boton1;public Hilos() {MenuBar barra;Menu cargadatos, ayuda, acerca, salir;MenuItem cardatos, ejecuc, listaeje, ayulis, acercade, fin;// Menú principal.barra = new MenuBar();setMenuBar(barra);// Agregado de submenú al principal.cargadatos = new Menu(”Configuración y Ejecución”, true);barra.add(cargadatos);// Creación de opciones del menú.cardatos = new MenuItem(”Datos de Configuración”);cardatos.addActionListener(this);cargadatos.add(cardatos);ejecuc = new MenuItem(”Ejecución Concurrente e Hilos”);ejecuc.addActionListener(this);cargadatos.add(ejecuc);listaeje = new MenuItem(”Lista Resultados de Ejecución”);listaeje.addActionListener(this);cargadatos.add(listaeje);// Agregado del submenú al principal.ayuda = new Menu(”Ayuda”, true);

barra.add(ayuda);// Creación de opciones del menú.ayulis = new MenuItem(”Listar Ayuda”);ayulis.addActionListener(this);ayuda.add(ayulis);// Agregado del submenú al principal.salir = new Menu(”Salir”, true);barra.add(salir);// Creación de opciones del menú.fin = new MenuItem(”Salir del Sistema”);fin.addActionListener(this);salir.add(fin);// Agregado del submenú al principal.acerca = new Menu(”Acerca de”, true);barra.add(acerca);// Creación de opciones del menú.acercade = new MenuItem(”Acerca del Sistema”);acercade.addActionListener(this);acerca.add(acercade);// Habilitación del cierre de la ventana.addWindowListener(new WindowAdapter() {public void windowClosing(WindowEvent e) {System.exit(0);}});}public void actionPerformed(ActionEvent evt) {MenuItem c = (MenuItem) evt.getSource();String arg = c.getLabel();if(arg.equals(”Salir del Sistema”)) {System.exit(0);}

else if(arg.equals(”Datos de Configuración”)) {// Para Datos de Configuración.// Lee datos de entrada.// Crea etiqueta para documento.VentanaDialogCH ventana=new VentanaDialogCH();ventana.setTitle(”Carga de Datos de Configuración”);ventana.setVisible(true);ventana.setBackground(Color.yellow);ventana.setForeground(Color.red);ventana.setSize(new Dimension(600,400));}

else if(arg.equals(”Ejecución Concurrente e Hilos”)) {// Para Ejecución Concurrente e Hilos.// Lee datos de entrada.// Crea etiqueta para documento.VentanaDialogECH ventana=new VentanaDialogECH();ventana.setTitle(”Realiza Ejecución Concurrente e Hilos”);ventana.setVisible(true);ventana.setBackground(Color.red);

ventana.setForeground(Color.yellow);ventana.setSize(new Dimension(600,400));}else if(arg.equals(”Lista Resultados de Ejecución”)) {// Para Lista Resultados de Ejecución.// Lee datos de entrada.// Crea etiqueta para documento.VentanaDialogLCH ventana=new VentanaDialogLCH();ventana.setTitle(”Lista Resultados de Ejecución Concurrente e Hilos”);ventana.setVisible(true);ventana.setBackground(Color.green);ventana.setForeground(Color.orange);ventana.setSize(new Dimension(600,400));}

else if(arg.equals(”Listar Ayuda”)) {// Para Listar Ayuda.// Lee datos de entrada.// Crea etiqueta para Listar Ayuda.VentanaDialogA ventana=new VentanaDialogA();ventana.setTitle(”Lista Ayuda”);ventana.setVisible(true);ventana.setBackground(Color.cyan);ventana.setForeground(Color.magenta);ventana.setSize(new Dimension(600,400));}

else if(arg.equals(”Acerca del Sistema”)) {// Para Acerca del Sistema.// Lee datos de entrada.// Crea etiqueta para Acerca del Sistema.VentanaDialogAS ventana=new VentanaDialogAS();ventana.setTitle(”Acerca del Sistema”);ventana.setVisible(true);ventana.setBackground(Color.orange);ventana.setForeground(Color.blue);ventana.setSize(new Dimension(600,400));}}

public static void main (String args[]) {// Creación del menú principal.Hilos menus = new Hilos();menus.setTitle(”Ejecución Concurrente e Hilos con JAVA”);menus.setVisible(true);menus.setBackground(Color.cyan);menus.setSize(new Dimension(850,650));// Creación de la imágen dinámica.VImaCanvas imagen1 = new VImaCanvas();imagen1.setTitle(”???????”);imagen1.setVisible(true);imagen1.setBackground(Color.orange);

imagen1.setSize(new Dimension(100,100));}}

class VentanaDialogCH extends Frame implements ActionListener{SimpleDialogCH dialog;TextArea textArea;Button boton1;public VentanaDialogCH(){textArea=new TextArea(5,40);textArea.setEditable(false);add(”Center”,textArea);boton1=new Button(”Diálogo p/ configuración”);boton1.addActionListener(this);Panel panel=new Panel();panel.add(boton1);add(”South”,panel);panel.setBackground(Color.yellow);addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){setVisible(false);}});

}public void actionPerformed(ActionEvent evt){String str=evt.getActionCommand();if(str.equals(”Diálogo p/ configuración”)){if(dialog==null)dialog=new SimpleDialogCH(this,”Configuración”);dialog.show();}}public void setText1(String stock){try {textArea.setFont(new Font(”Times”, 1, 11));textArea.setForeground(Color.orange);String asterisc = ”\n*************************************”;textArea.append(asterisc);textArea.append(”\nNúmero inicial de bu¤ers ocupados: ” + stock + ”.”);}catch (java.lang.Exception ex) {// Atrapa excepciones y las despliega.ex.printStackTrace ();}try {File f0 = new File (”Hilos.txt”);f0.delete();RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;longitud = 0;f1.seek(longitud);f1.writeUTF(stock);f1.close();

}catch (Exception e) {System.out.println(”Archivo Hilos: Salida en grabación de parámetros: ” + e);}}public void setText2(String maxcompra){try {textArea.append(”\nNúmero máximo de bu¤ers leidos por vez: ” + maxcompra + ”.”);}catch (java.lang.Exception ex) {// Atrapa excepciones y las despliega.ex.printStackTrace ();}try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;longitud = f1.length();f1.seek(longitud);f1.writeUTF(maxcompra);f1.close();}catch (Exception e) {System.out.println(”Archivo Hilos: Salida en grabación de parámetros: ” + e);}}public void setText3(String limitereponer){try {textArea.append(”\nNúmero mínimo de bu¤ers ocupados antes de grabar más: ” +limitereponer + ”.”);}catch (java.lang.Exception ex) {// Atrapa excepciones y las despliega.ex.printStackTrace ();}try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;longitud = f1.length();f1.seek(longitud);f1.writeUTF(limitereponer);f1.close();}catch (Exception e) {System.out.println(”Archivo Hilos: Salida en grabación de parámetros: ” + e);}}

public void setText4(String cantidadreponer){try {textArea.append(”\nNúmero de bu¤ers grabados por vez: ” + cantidadreponer + ”.”);}catch (java.lang.Exception ex) {// Atrapa excepciones y las despliega.ex.printStackTrace ();

}try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;longitud = f1.length();f1.seek(longitud);f1.writeUTF(cantidadreponer);f1.close();}catch (Exception e) {System.out.println(”Archivo Hilos: Salida en grabación de parámetros: ” + e);}}public void setText5(String tiempoapertura){try {String asterisc = ”\n*************************************”;textArea.append(”\nNúmero de milisegundos de la simulación: ” + tiempoapertura +”.”);textArea.append(asterisc);textArea.append(”\n ”);}catch (java.lang.Exception ex) {// Atrapa excepciones y las despliega.ex.printStackTrace ();}try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;longitud = f1.length();f1.seek(longitud);f1.writeUTF(tiempoapertura);f1.close();}catch (Exception e) {System.out.println(”Archivo Hilos: Salida en grabación de parámetros: ” + e);}}}class SimpleDialogCH extends Dialog implements ActionListener{TextField tstock, tmaxcompra, tlimitereponer, tcantidadreponer, ttiempoapertura;VentanaDialogCH parent;

Button b1;public String stock;public String MAXCOMPRA;public String LIMITEREPONER;public String CANTIDADREPONER;public String TIEMPOAPERTURA;public SimpleDialogCH(Frame fr,String titulo){super(fr,titulo,true);

parent=(VentanaDialogCH)fr;Panel p1=new Panel();

Label etiqueta1=new Label(”Número inicial de buffers ocupados (0):”);p1.add(etiqueta1);tstock=new TextField(”0”,4);p1.add(tstock);add(”Center”,p1);Label etiqueta2=new Label(”Número máximo de buffers leidos por vez (30):”);p1.add(etiqueta2);tmaxcompra=new TextField(”30”,4);p1.add(tmaxcompra);add(”Center”,p1);Label etiqueta3=new Label(”Número mínimo de buffers ocupados antes de grabar más(40):”);p1.add(etiqueta3);tlimitereponer=new TextField(”40”,4);p1.add(tlimitereponer);add(”Center”,p1);Label etiqueta4=new Label(”Número de buffers grabados por vez (50):”);p1.add(etiqueta4);tcantidadreponer=new TextField(”50”,4);p1.add(tcantidadreponer);add(”Center”,p1);Label etiqueta5=new Label(”Número de milisegundos de la ejecución (2000):”);p1.add(etiqueta5);ttiempoapertura=new TextField(”2000”,4);p1.add(ttiempoapertura);add(”Center”,p1);Panel p2=new Panel();p2.setLayout(new FlowLayout(FlowLayout.RIGHT));b1=new Button(”Cancelar”);b1.addActionListener(this);Button b2=new Button(”Aceptar”);b2.addActionListener(this);p2.add(b1);p2.add(b2);add(”South”,p2);setSize(500,200);}

public void actionPerformed(ActionEvent evt){String str=evt.getActionCommand();if(str.equals(”Aceptar”))parent.setText1(tstock.getText());stock = tstock.getText();parent.setText2(tmaxcompra.getText());MAXCOMPRA = tmaxcompra.getText();parent.setText3(tlimitereponer.getText());LIMITEREPONER = tlimitereponer.getText();parent.setText4(tcantidadreponer.getText());CANTIDADREPONER = tcantidadreponer.getText();parent.setText5(ttiempoapertura.getText());TIEMPOAPERTURA = ttiempoapertura.getText();setVisible(false);}}

class VentanaDialogECH extends Frame implements ActionListener{TextArea textArea;public VentanaDialogECH(){textArea=new TextArea(5,40);textArea.setEditable(false);add(”Center”,textArea);String stock, maxcompra, limitereponer, cantidadreponer, tiempoapertura;stock = ””; maxcompra = ””; limitereponer = ””;cantidadreponer = ””; tiempoapertura = ””;addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){setVisible(false);}});try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;longitud = 0;f1.seek(longitud);stock = f1.readUTF();maxcompra = f1.readUTF();limitereponer = f1.readUTF();cantidadreponer = f1.readUTF();tiempoapertura = f1.readUTF();f1.close();}

catch (Exception e) {System.out.println(”Archivo Hilos: Salida luego de leer parámetros para actualizar datos: ” +e);}

try {Almacen a = new Almacen();Productor p1 = new Productor(a,1);Productor p2 = new Productor(a,2);Consumidor c1 = new Consumidor(a,1);Consumidor c2 = new Consumidor(a,2);Consumidor c3 = new Consumidor(a,3);a.stock = Integer.parseInt(stock);a.MAXCOMPRA = Integer.parseInt(maxcompra);a.LIMITEREPONER = Integer.parseInt(limitereponer);a.CANTIDADREPONER = Integer.parseInt(cantidadreponer);a.TIEMPOAPERTURA = Integer.parseInt(tiempoapertura);p1.start();p2.start();c1.start();c2.start();c3.start();}

catch (java.lang.Exception ex) {

// Atrapa excepciones y las despliega.ex.printStackTrace ();}

try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;String c, d, asterisc;longitud = 0;f1.seek(longitud);asterisc = ”\n*************************************”;d = ”\n ”;textArea.setFont(new Font(”Times”, 1, 11));textArea.setForeground(Color.red);textArea.append(asterisc);textArea.append(”\nInicio de la ejecución concurrente con hilos.”);textArea.append(”\nLos datos de configuración son los siguientes: ”);c = f1.readUTF();textArea.append(”\nNúmero inicial de bu¤ers ocupados: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero máximo de bu¤ers leidos por vez: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero mínimo de bu¤ers ocupados antes de grabar más: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero de bu¤ers grabados por vez: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero de milisegundos de la ejecución: ” + c + ”.”);textArea.append(asterisc);textArea.append(d);f1.close();}catch (Exception e) {System.out.println(”Archivo Hilos: Salida luego de leer parámetros para desplegarlos: ” + e);}

}public void actionPerformed(ActionEvent evt){String str=evt.getActionCommand();}

}class VentanaDialogLCH extends Frame implements ActionListener{TextArea textArea;public VentanaDialogLCH(){textArea=new TextArea(5,40);textArea.setEditable(false);add(”Center”,textArea);addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){setVisible(false);}});

try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;String c, d, asterisc;longitud = 0;f1.seek(longitud);asterisc = ”\n*************************************”;d = ”\n ”;textArea.setFont(new Font(”Times”, 1, 11));textArea.setForeground(Color.red);textArea.append(asterisc);textArea.append(”\nInicio de la ejecución concurrente con hilos.”);textArea.append(”\nLos datos de configuración son los siguientes: ”);c = f1.readUTF();textArea.append(”\nNúmero inicial de buffers ocupados: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero máximo de buffers leidos por vez: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero mínimo de buffers ocupados antes de grabar más: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero de buffers grabados por vez: ” + c + ”.”);c = f1.readUTF();textArea.append(”\nNúmero de milisegundos de la ejecución: ” + c + ”.”);textArea.append(asterisc);textArea.append(d);while ((c = f1.readUTF()) != null) {textArea.append(c);textArea.append(d);}

f1.close();}catch (Exception e) {System.out.println(”Archivo Hilos: Salida luego de leer parámetros para desplegarlos: ” + e);}}public void actionPerformed(ActionEvent evt){String str=evt.getActionCommand();}}

class VentanaDialogA extends Frame implements ActionListener{TextArea textArea;public VentanaDialogA(){textArea=new TextArea(5,40);textArea.setEditable(false);add(”Center”,textArea);addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){setVisible(false);}});

try {String asterisc = ”\n *************************************************”;textArea.setFont(new Font(”Times”, 1, 11));textArea.setForeground(Color.blue);textArea.append(”\n ”);textArea.append(asterisc);textArea.append(”\n ”);textArea.append(”\n Ayuda para la ejecución concurrente e hilos con JAVA.”);textArea.append(”\n ******************************************************”);textArea.append(”\n ”);textArea.append(”\n El ejemplo contempla el problema de productores / consumidores:”);textArea.append(”\n * Los hilos productores graban (y ocupan) buffers en un pool”);textArea.append(”\n de buffers disponibles.”);textArea.append(”\n * Los hilos consumidores leen (y liberan) buffers del pool”);textArea.append(”\n de buffers disponibles.”);textArea.append(”\n ”);textArea.append(”\n Las opciones previstas contemplan lo siguiente:”);textArea.append(”\n * Carga de datos de configuración de la ejecución.”);textArea.append(”\n * Ejecución propiamente dicha.”);textArea.append(”\n * Listado de los resultados por pantalla.”);textArea.append(”\n ”);textArea.append(”\n Los datos se cargan interactivamente por pantalla, ”);textArea.append(”\n donde se sugieren valores de referencia.”);textArea.append(”\n ”);textArea.append(”\n Los resultados se graban en el archivo Hilos.txt,”);textArea.append(”\n como registros de longitud variable.”);textArea.append(”\n ”);textArea.append(”\n ”);textArea.append(asterisc);textArea.append(”\n ”);}

catch (java.lang.Exception ex) {// Atrapa otro tipo de excepciones y las despliega.ex.printStackTrace ();}}public void actionPerformed(ActionEvent evt){String str=evt.getActionCommand();}}

class VentanaDialogAS extends Frame implements ActionListener{TextArea textArea;public VentanaDialogAS(){textArea=new TextArea(5,40);textArea.setEditable(false);add(”Center”,textArea);addWindowListener(new WindowAdapter(){public void windowClosing(WindowEvent e){setVisible(false);}});

try {String asterisc = ”\n *************************************************”;textArea.setFont(new Font(”Times”, 1, 11));textArea.setForeground(Color.black);textArea.append(”\n ”);textArea.append(asterisc);textArea.append(”\n ”);textArea.append(”\n Acerca del sistema de concurrencia e hilos con JAVA.”);textArea.append(”\n ****************************************************”);textArea.append(”\n ”);textArea.append(”\n Trabajo práctico de Sistemas Operativos.”);textArea.append(”\n Licenciatura en Sistemas.”);textArea.append(”\n Universidad Nacional del Nordeste (Argentina).”);textArea.append(”\n ”);textArea.append(”\n ”);textArea.append(asterisc);textArea.append(”\n ”);}

catch (java.lang.Exception ex) {// Atrapa otro tipo de excepciones y las despliega.ex.printStackTrace ();}

}public void actionPerformed(ActionEvent evt){String str=evt.getActionCommand();}}

class VImaCanvas extends Frameimplements AdjustmentListener {Image imagen1;ImaCanvas imaani;Panel panel;public VImaCanvas(){setLayout(new BorderLayout());panel = new Panel();// Agregado de la imagen animada.imagen1 = Toolkit.getDefaultToolkit().getImage(”Ani0076.gif”);imaani = new ImaCanvas(imagen1);panel.add(imaani);add(”Center”,imaani);}public void adjustmentValueChanged(AdjustmentEvent evt){imaani.repaint();}}

class ImaCanvas extends Canvas{Image img;int x,y;public ImaCanvas(Image imagen1){img=imagen1;x=0;y=0;}public void paint(Graphics g){g.drawImage(img,0,0,this);}}

class Productor extends Thread {private Almacen almacen;private int numero;public Productor(Almacen a, int numero) {almacen = a;this.numero = numero;}public void run() {while(!almacen.cerrado){if(System.currentTimeMillis()-almacen.hora>almacen.TIEMPOAPERTURA){almacen.cerrado=true;try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;String c;c = ”Fin de la ejecución.”;longitud = f1.length();f1.seek(longitud);f1.writeUTF(c);f1.close();}

catch (Exception e) {System.out.println(”Archivo Hilos: Salida luego de grabar Fin de la ejecución: ” + e);}}almacen.reponer(numero);try {sleep((int)(Math.random() * 100));}catch (InterruptedException e) {}}}}

class Consumidor extends Thread {private Almacen almacen;private int numero;

public Consumidor(Almacen a, int numero) {almacen = a;this.numero = numero;}public void run() {int value;while(!almacen.cerrado){value=(int)(Math.random()*almacen.MAXCOMPRA);almacen.comprar(numero,value);}}}

class Almacen {public int stock=0;private boolean necesitareponer;public boolean cerrado=false;public int MAXCOMPRA=0;public int LIMITEREPONER=0;public int CANTIDADREPONER=0;public long TIEMPOAPERTURA=0;long hora=System.currentTimeMillis();public synchronized void comprar(int consumidor,int cantidad) {while (necesitareponer == true) {try { wait();} catch (InterruptedException e) {}}if(!cerrado){if(stock<cantidad){cantidad=stock;}stock-=cantidad;try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;String c;c = ”Quedan ” + stock + ” unidades. El Consumidor ” + consumidor + ” ha leido ”+cantidad+” unidades.”;longitud = f1.length();f1.seek(longitud);f1.writeUTF(c);f1.close();}catch (Exception e) {System.out.println(”Archivo Hilos: Salida luego de grabar Hilo Consumidor: ” + e);}if(stock<=LIMITEREPONER)necesitareponer = true;}notify();}public synchronized void reponer(int productor) {

if (!cerrado){while (necesitareponer == false) {try { wait();} catch (InterruptedException e) {}}stock+=CANTIDADREPONER;

try {RandomAccessFile f1 = new RandomAccessFile (”Hilos.txt”, ”rw”);long longitud;String c;c = ”Quedan ” + stock + ” unidades. El Productor ” + productor + ” ha grabado ” +CANTIDADREPONER + ” unidades.”;longitud = f1.length();f1.seek(longitud);f1.writeUTF(c);f1.close();}

catch (Exception e) {System.out.println(”Archivo Hilos: Salida luego de grabar Hilo Productor: ” + e);}necesitareponer = false;}notify();}}

Taller1. Correr todos los ejemplos citados para comprobar la estructura de un hilo

y explicar los procesos que se ejecutan.

2. Con base en sus conocimientos en programación, desarrolle un programaque aplique el concepto de threads, y relaciónelo con lo visto hasta ahoraen clase. Este programa debe estar debidamente documentado y manejarpor lo menos cuatro hilos. Este programa lo puede desarrollar en ellenguaje que maneje, en la que por cada hilo debe estar explicadodebidamente en el trabajo y tutorial.

Hilo de ejecución

Software

Transcript of Hilo de ejecución