Вы находитесь на странице: 1из 26

UNIVERSIDAD DE PANAM

CENTRO REGIONAL UNIVERSITARIO DE VERAGUAS


FACULTAD DE INFORMTICA, ELECTRNICA Y
COMUNICACIN
LICENCIATURA EN INGENIERA EN INFORMTICA
ASIGNATURASISTEMA OPERATIVO Y ARQUITECTURA DE
COMPUTADORAS
CAPITULO IV
TEMA: HEBRAS

PROFESOR: RAL DUTARI

BUITRAGO, HCTOR

9-722-1928

GONZLEZ, MARA

2-721-522

AO 2010

Hebras 201
0

Contenido
I.

Introduccin................................................................................................ 4

II.

Objetivos.................................................................................................... 5
2.1

Objetivos Generales............................................................................... 5

2.2

Objetivos Especficos............................................................................. 5
Definicin de Hebras................................................................................. 6

III.
3.1

Motivacin............................................................................................ 6

3.2

Ventajas............................................................................................... 7
Modelos Multihebras................................................................................. 8

IV.
4.1

Modelo muchos a uno............................................................................ 8

4.2

Modelo uno a uno.................................................................................. 9

4.3

Modelo de muchos a muchos..................................................................9

Bibliotecas de Hebras................................................................................. 11

V.

5.1.

Pthreads............................................................................................ 12

5.2.

Hebras de Win32................................................................................. 12

5.3.

Hebras de Java................................................................................... 13

VI.

Consideraciones sobre las Hebras............................................................15

6.1.

Cancelacin........................................................................................ 15

6.2.

Tratamiento de Seales........................................................................17

6.3.

Conjuntos compartidos de hebras..........................................................19

6.4

Datos especficos de una Hebra............................................................20

6.5

Activaciones del Planificador.................................................................20

VII.

Ejemplos de Sistemas Operativos.............................................................22

Hebras 201
0
7.1.

Hebras de Windows XP........................................................................22

7.2

Hebras de Linux.................................................................................. 23

VIII.

Conclusiones......................................................................................... 25

IX.

Referencias........................................................................................... 26

Tabla de Ilustraciones
Ilustracin 1-Proceso Monohebra y Multihebra.......................................................7
Ilustracin 2-Modelo de muchos a uno..................................................................9
Ilustracin 3-Modelo uno a uno..........................................................................10
Ilustracin 4-Modelo muchos a muchos...............................................................10
Ilustracin 5-Modelo de dos niveles....................................................................11
Ilustracin 6-Programa C multihebra usando la API de Pthreads.............................14
Ilustracin 7-Programa C multihebra usando la API de Win32.................................16
Ilustracin 8-Programa Java para el sumario de un entero negativo........................18
Ilustracin 9-Proceso Ligero (LWP).....................................................................21
Ilustracin 10-Estructura de Datos de una Hebra de Windows XP...........................24

Hebras 201
0

I.

Introduccin
La mayora de los sistemas operativos modernos proporcionan caractersticas
que permiten que un proceso tenga mltiples hebras de control.
Una vez que el usuario solicita la ejecucin de un programa, ste es cargado
por el Sistema Operativo (SO) y desde este momento es considerado un
proceso. En otras palabras, un proceso es un programa que ya fue cargado y
est en condiciones de ejecucin. Una hebra es, bsicamente, la secuencia de
ejecucin de instrucciones de un programa.
Este trabajo presenta diversos conceptos asociados con los sistemas
informticos multihebra, incluyendo una exposicin sobre las API de las
bibliotecas de hebras de Pthreads, Win32 y Java. Tambin temas relacionados
con la programacin multihebra y cmo afecta esta caracterstica al diseo de
sistemas operativos.

Hebras 201
0

II.

Objetivos
II.1

Objetivos Generales

Presentar el concepto de hebra, una unidad fundamental de


utilizacin de la CPU que conforma los fundamentos de los
sistemas informticos multihebra.

Explicar las API de las bibliotecas de hebras de Pthreads, Win32


y Java.

II.2

Objetivos Especficos

Conocer las ventajas de la programacin multihebras.

Definir los modelos multihebras.

Hebras 201
0

III.

Definicin de Hebras
Una hebra es una unidad bsica de utilizacin de la CPU. Comprende un ID de
hebra, un contador de programas, un conjunto de registros y una pila.
Comparte con otras hebras que pertenecen al mismo proceso la seccin de
cdigo, la seccin de datos y otros recursos del sistema operativo, como los
archivos abiertos y las seales. [SIGA06]
Un proceso tradicional tiene una sola hebra de control; si un proceso tiene
mltiples hebras de control, puede realizar ms de una tarea a la vez.
La ilustracin 1 muestra la diferencia entre un proceso tradicional monohebra y
un proceso multihebra. [SIGA06]

III.1 Motivacin
Muchos paquetes de software que se ejecutan en los PC modernos de
escritorio son multihebra. Normalmente, una aplicacin se implementa como un
proceso propio con varias hebras de control. Un procesador de textos puede
tener una hebra para mostrar grficos, otra hebra para responder a las
pulsaciones de teclado del usuario y una tercera hebra para el corrector
ortogrfico y gramatical que se ejecuta en segundo plano. [SIGA06]
Las hebras tambin juegan un papel importante en los sistemas de llamada a
procedimientos remotos (RPC). Normalmente, los servidores RPC son
multihebra. Ahora muchos kernel de sistemas operativos son multihebra.

Hebras 201
0

Ilustracin 1-Proceso Monohebra y Multihebra

Hay varias hebras operando en el kernel y cada hebra realiza una tarea
especfica, tal como gestionar dispositivos o tratar interrupciones.

III.2 Ventajas
Las ventajas

de la programacin multihebra pueden dividirse en cuatro

categoras principales:
Capacidad de respuesta: el uso de mltiples hebras en una aplicacin
interactiva, permite que un programa contine ejecutndose, incluso parte de l
este bloqueado o realizando unas operaciones muy larga, lo que incrementa la
capacidad de respuestas al usuario. [SIGA06]
Comparticin de recursos: las hebras comparten la memoria y los recursos del
proceso al que pertenecen. La ventaja de compartir el cdigo y los datos es que

Hebras 201
0
permite que una aplicacin tenga hebras de actividad dentro del mismo espacio
de direcciones. [SIGA06]
Economa: la asignacin de memoria y recursos para la creacin de procesos
es costosa, dado que las hebras comparten recursos del proceso al que
pertenecen, es ms econmico crear y realizar cambios de contexto entre unas
y otras hebras. [SIGA06]
Utilizacin

sobre

arquitecturas

multiprocesador:

las

ventajas

de

usar

configuraciones multihebras pueden verse incrementadas significativamente en


una arquitectura multiprocesador, donde las hebras pueden ejecutarse en
paralelo en los diferentes procesadores. Un proceso monohebra solo se puede
ejecutar en una CPU, independientemente de cuantas haya disponibles.
[SIGA06]

IV. Modelos Multihebras


El soporte para hebras puede proporcionarse en el nivel de usuario o por parte
del kernel. El soporte para las hebras de usuario se proporciona por encima del
kernel y las hebras se gestionan sin soporte del mismo, mientras que el sistema
operativo soporta y gestiona directamente las hebras del kernel. Debe existir
una relacin entre las hebras de usuario y las del kernel, aqu se ver tres
formas de establecer esta seccin. [SIGA06]

IV.1 Modelo muchos a uno


El modelo de la ilustracin 2 asigna mltiples hebras del nivel de usuario a una
hebra del kernel. La gestin de hebras mediante la biblioteca de hebras en el
espacio de usuario, por lo que resulta eficiente, pero el proceso completo se
bloquea si una hebra realiza una llamada bloqueante al sistema. [SIGA06]

Hebras 201
0

Ilustracin 2-Modelo de muchos a uno

IV.2 Modelo uno a uno


El modelo uno a uno de la ilustracin 3 asigna cada hebra de usuario a una
hebra del kernel. El nico inconveniente de este modelo es crear una hebra de
usuario requiere crear la correspondiente hebra del kernel, dado que la carga
de trabajo administrativa para la creacin de hebras del kernel puede repercutir
en el rendimiento de una aplicacin, la mayora de las implementaciones de
este modelo restringen el nmero de hebras soportadas por el sistema.
[SIGA06]

IV.3 Modelo de muchos a muchos


El modelo muchos a muchos de la ilustracin 4 multiplex muchas hebras de
usuarios sobre un nmero menor o igual de hebras del kernel. [SIGA06]

Hebras 201
0
El nmero de hebras del kernel puede ser especfico de una determinada
aplicacin o de una determinada mquina. Mientras que el modelo de muchos a
uno permite al desarrollador crear tantas hebras de usuario como desee, ya que
el kernel solo puede planificar la ejecucin de una hebra cada vez.
El modelo uno a uno permite una mayor concurrencia, pero el desarrollador
debe tener cuidado de no crea demasiadas hebras dentro de una aplicacin. El
modelo muchos a muchos no sufre ninguno de estos inconvenientes. Los
desarrolladores pueden crear tantas hebras de usuario como sean necesarias y
las correspondientes hebras del kernel pueden ejecutarse en paralelo en un
multiprocesador. [SIGA06]

Ilustracin 3-Modelo uno a uno

10

Hebras 201
0

Ilustracin 4-Modelo muchos a muchos

11

Hebras 201
0
Una popular variacin del modelo muchos a muchos multiplexa hebras del nivel
de usuario sobre un nmero menor o igual de hebras del kernel, pero tambin
permite acoplar una hebra de usuario a una hebra del kernel. Esta variante
algunas veces se dominan modelo de dos niveles ver ilustracin 5.

Ilustracin 5-Modelo de dos niveles

V. Bibliotecas de Hebras
Una biblioteca de hebras proporciona al programador una API para crear y
gestionar hebras. Existen dos formas principales de implementar una biblioteca
de hebras: el primer mtodo consiste en proporcionar una biblioteca
enteramente en el espacio de usuario, si ningn soporte del kernel; el segundo
mtodo consiste en implementar una biblioteca en el nivel del kernel, soportada
directamente por el sistema operativo. [SIGA06]
Las tres principales bibliotecas de hebras actualmente en uso son:
POSIX Pthreads

12

Hebras 201
0
Win32
Java
Pthreads puede proporcionar como biblioteca del nivel de usuario o del nivel de
kernel. La biblioteca de hebras de Win32 es una biblioteca del nivel de kernel
disponible en los sistemas Windows. [SIGA06]
La API de hebras Java permite crear y gestionar directamente hebras en los
programas Java. Sin embargo, puesto que en la mayora de los casos la JVM
se ejecuta por encima del sistema operativo del host. [SIGA06]

5.1. Pthreads
Pthreads se basa en el estndar POSIX que define una API para la creacin y
sincronizacin

de

hebras.

Se

trata

de

una

especificacin

para

el

comportamiento de las hebras, no de una implementacin. Los diseadores de


sistemas operativos pueden implementar la especificacin de la forma que se
deseen.
El programa C mostrado en la ilustracin 6 muestra la API bsica de Pthreads
mediante un ejemplo de creacin de un programa multihebra, las diferentes
hebras inician su ejecucin en una funcin especfica. [SIGA06]

5.2. Hebras de Win32


La tcnica de creacin de hebras usando la biblioteca de hebras de Win32 es
similar en varios aspectos a la tcnica empleada en Pthreads. Se ilustrara la
API para hebras Win32 mediante el programa C de la ilustracin 7. Se
observara que se tiene que incluir el archivo de cabecera windows.h cuando se
usa la API de Win32. [SIGA06]

13

Hebras 201
0
5.3. Hebras de Java
Las hebras son el modelo fundamental de ejecucin de programas en un
programa Java y el lenguaje Java y su API proporciona un rico conjunto de
caractersticas para la creacin y gestin de hebras. Todos los programas Java
tienen al menos una hebrea de control, incluso un sencillo programa Java que
solo consta de un mtodo main () que se ejecuta como hebra en la mquina
virtual Java. [SIGA06]
Existen dos tcnicas para crear hebras en un programa Java. Un mtodo
consiste en crear una nueva clase que se derive de la clase Thread y sustituir
apropiadamente

su mtodo run (). Una tcnica alternativa frecuentemente

utilizada en definir una clase que implemente la interface Runnable. Esta


inteface se define como sigue:
Public interface Runnable
{
Public abstract void main();
}
La ilustracin 8 muestra la versin Java de un programa multihebra que calcula
el sumatorio de un entero no negativo. [SIGA06]

14

Hebras 201
0

Ilustracin 6-Programa C multihebra usando la API de Pthreads

15

Hebras 201
0
VI.

Consideraciones sobre las Hebras


Se ver algunas de las cuestiones que hay que tener en cuenta en los
programas multihebras.

6.1. Cancelacin
La cancelacin de una hebra es la accin de terminar una hebra antes de que
se haya completado. [SIGA06]
Una hebra que haya sido cancelada se denomina a menudo hebra objetivo. La
cancelacin de una hebra objetivo puede ocurrir en dos escenarios diferentes:
Cancelacin

asncrona:

una

determinada

hebra

hace

que

termine

inmediatamente la hebra objetivo. [SIGA06]


Cancelacin diferida: la hebra objetivo comprueba peridicamente si debe
terminar lo que la proporciona una oportunidad de terminar por si misma de una
forma ordenada. [SIGA06]

16

Hebras 201
0

La

Ilustracin 7-Programa C multihebra usando la API de Win32


dificultad de la cancelacin se produce en aquellas situaciones en las que se

17

Hebras 201
0
han asignado recursos a una hebra cancelada o cuando una hebra se cancela
en mitad de una actualizacin de datos que tuviera compartidos con otras
hebras. Estos problemas son especialmente graves

cuando se utiliza el

mecanismo de cancelacin asncrona. [SIGA06]

6.2. Tratamiento de Seales


Una seal se usa en los sistemas UNIX para notificar a un proceso que se ha
producido en determinado suceso. Una seal puede recibirse sncrona o
asncronamente, dependiendo del origen y de la razn por la que el suceso
deba ser sealizado. Todas las seales siguen el mismo patrn:

Una seal se genera debido a que se produce un determinado suceso.

La seal generada se suministra a un proceso.

Una vez suministrada la seal debe ser tratada.

Cada seal puede ser tratada por una de dos posibles rutinas de tratamiento:

Una rutina de tratamiento de seal predeterminada.

Una rutina de tratamiento de seal definida por el usuario.

Cada seal tiene una rutina de tratamiento de seal predeterminada que el


kernel ejecuta cuando trata dicha seal. Las seales pueden tratarse de
diferentes formas: algunas seales simplemente pueden ignorarse; otras
pueden tratarse mediante la terminacin del programa. [SIGA06]
El tratamiento de seales en programa de una sola hebra resulta sencillo, las
seales siempre se suministran a un proceso. Sin embargo, suministrar las
seales en los programas multihebras es ms complicado, ya que un proceso
puede tener varias hebras. [SIGA06]

18

Hebras 201
0

Ilustracin 8-Programa Java para el sumario de un entero negativo

19

Hebras 201
0
Hay disponible las siguientes opciones:

Suministrar la seal a la hebra a la que sea aplicable la seal.

Suministrar la seal a todas las hebras del proceso.

Suministrar la seal a determinadas hebras del proceso.

Asignar una hebra especfica para recibir todas las seales del proceso.

6.3. Conjuntos compartidos de hebras


Un nmero ilimitado de hebras podra agotar determinados recursos del sistema
como el tiempo de CPU o la memoria. Una solucin para este problema
consiste en usar lo que se denomina un conjunto compartido de hebras.
La idea general subyacente a los conjuntos de hebras es la de crear una serie
de hebras al principio del proyecto y colocarlas en un conjunto compartido,
donde las hebras quedan a la espera de que se les asigne un trabajo. Cuando
un servidor recibe una solicitud, despierta a una hebra del conjunto y le pasa la
solicitud para que la hebra se encargue de darle servicio. Si el conjunto no tiene
una hebra libre el servidor espera hasta que quede una libre. [SIGA06]
Los conjuntos compartidos de hebras tienen las siguientes ventajas:
Dar servicio a una solicitud con una hebra existente normalmente es ms
rpido que esperar a crear una hebra.
Un conjunto de hebras limita el nmero de hebras existentes en cualquier
instante dado. Esto es particularmente importante en aquellos sistemas
que no puedan soportar un gran nmero de hebras concurrentes.
Las arquitecturas de conjuntos de hebras ms complejas pueden ajustar
dinmicamente el nmero de hebras del conjunto de acuerdo con los patrones

20

Hebras 201
0
de uso. Tales arquitecturas proporcionan la importante ventaja de tener un
conjunto compartido ms pequeo, que consume menos memoria, cuando la
carga del sistema es baja. [SIGA06]

6.4 Datos especficos de una Hebra


Las hebras que pertenecen a un mismo proceso comparten los datos del
proceso. Sin embargo cada hebra puede necesitar su propia copia de ciertos
datos, llamaremos a dichos datos: datos especficos de la hebra. [SIGA06]
Para asociar cada hebra con su identificador unvoco, podemos ejemplar los
datos especficos de la hebra. La mayor parte de las bibliotecas de hebras,
incluyendo Win32 y Pthreads, proporcionan ciertos mecanismos de soporte
para los datos especficos de las hebras. Java tambin proporciona soporte
para este tipo de datos. [SIGA06]

6.5 Activaciones del Planificador


Una ltima cuestin que hay que considerar en los programas multihebra
concierne a los mecanismos de comunicacin entre el kernel y la biblioteca de
hebras que puedan ser necesarios para los modelos muchos a muchos y de
dos niveles vistos anteriormente. [SIGA06]
Muchos sistemas que implementan el modelo muchos a muchos o el modelo de
dos niveles colocan una estructura de datos intermedia entre hebras de usuario
y del kernel. Esta estructura de datos conocida normalmente con el nombre de
proceso ligero o LWP (lightweight process) ver ilustracin 9.
A la biblioteca de hebras de usuario, el proceso ligero le parece un procesador
virtual en el que la aplicacin puede hacer que se ejecute una hebra de usuario.
Cada LWP se asocia a una hebra del kernel y es sta hebra del kernel la que el
sistema operativo ejecuta en los procesadores fsicos. Si una hebra del kernel

21

Hebras 201
0
se bloquea, el proceso ligero LWP se bloquea tambin y la hebra de usuario
asociada al LWP tambin se bloquea. [SIGA06]
Una aplicacin puede requerir un nmero cualquiera de procesos ligeros para
ejecutarse de forma eficiente. Normalmente se necesita un proceso ligero por
cada llamada concurrente al sistema que sea de tipo bloqueante. [SIGA06]
Un posible esquema de comunicacin entre la biblioteca de hebras de usuario y
el kernel es el que se conoce con el nombre de activacin del planificador que
funciona como sigue: el kernel proporciona a la aplicacin un conjunto de
procesos virtuales (LWP) y la aplicacin puede planificar la ejecucin de las
hebras de usuario en uno de los procesadores virtuales disponibles. [SIGA06]

Ilustracin 9-Proceso Ligero (LWP)

22

Hebras 201
0

VII.

Ejemplos de Sistemas Operativos


Se explorara como se implementan las hebras en los sistemas Windows XP y
Linux. [SIGA06]

7.1. Hebras de Windows XP


Windows XP implementa la API Win32. Esta API es la principal interfaz de
programacin de aplicaciones de la familia de sistemas operativos Microsoft
(Windows 95, 98, NT, 2000 y XP). [SIGA06]
Una aplicacin de Windows XP se ejecuta como un proceso independiente y
cada proceso puede contener una o ms hebras. Con la biblioteca de hebras,
cualquier hebra perteneciente a un proceso puede acceder al espacio de
direcciones de dicho procesos. [SIGA06]
Los componentes generales de una hebra son:
Un identificador de hebra que identifique de forma unvoca la hebra.
Un conjunto de registros que represente el estado del procesador.
Una pila de usuario, empleada cuando la hebra esta ejecutndose en
modo usuario y una pila del kernel. Empleada cuando la hebra se est
ejecutando en modo kernel.
Un rea de almacenamiento privada usada por las distintas bibliotecas
de tiempo de ejecucin y bibliotecas de enlace dinmico (DLL). La
estructura de una hebra de Windows XP se muestra en la ilustracin 10.

23

Hebras 201
0
7.2 Hebras de Linux
Linux no diferencia entre procesos y hebras. Generalmente Linux utiliza el
trmino tarea en lugar de proceso y hebra, para hacer referencia a un flujo de
control dentro de un programa. [SIGA06]
El nivel variable de comparticin es posible por la forma en que se representa
una tarea en el kernel de Linux. Existe una estructura de datos del kernel
especfica para cada tarea del sistema; esta estructura contiene punteros a
otras estructuras en las que se almacenan dichos datos, por ejemplo
estructuras de datos que representan la lista de archivos abiertos informacin
sobre el tratamiento de seales y la memoria virtual. [SIGA06]

Ilustracin 10-Estructura de Datos de una Hebra de Windows XP

24

Hebras 201
0
VIII.

Conclusiones
Las ventajas de los mecanismos multihebra son que proporcionan una mayor
capacidad de respuestas al usuario, la comparticin de recursos dentro del
proceso, una mayor economa y la capacidad de aprovechar las ventajas de las
arquitecturas multiprocesador.
Las hebras de nivel de usuario son hebras visibles para el programador y
desconocidos para el kernel. El kernel de los sistemas operativos soporta y
gestiona las hebras del nivel del kernel.
La mayora de los sistemas operativos modernos proporcionan soporte para
hebras en el kernel. Las bibliotecas de hebras proporcionan al programador de
la aplicacin una API para crear y gestionar hebras.

25

Hebras 201
0

IX.

Referencias
[SIGA06]

SILBERSCHATS, Abraham; GALVIN, Peter; GAGNE, Greg.


Fundamentos de sistemas operativos. Sptima edicin. Espaa.
Mc Graw Hill. 2006.

26

Вам также может понравиться