Hebras

Introducción

Una hebra es una unidad básica de utilización de la CPU, el cual es compuesto por un ID de hebra, un controlador de programa, un conjunto de registros y una pila. Las hebras pueden compartir datos con otras hebras siempre y cuando pertenezcan al mismo proceso los cuales pueden ser de las secciones de código, sección de datos y otros recursos del sistema operativo, como los archivos abierto y señales.

Un proceso tradicional, también llamado proceso pesado, es un proceso de una sola hebra, por el contrario, si un proceso tiene múltiples hebras de control, se puede realizar más de una tarea a la vez.

Hebras

La mayoría de paquetes de software que se ejecutan en las computadoras modernas de escritorio son multihebra, en los cuales una aplicación se implementa como un proceso propio con varias hebras de control. Por ejemplo, un explorador web puede tener una hebra para mostrar imágenes o texto, mientras otra hebra recupera datos de la red.

Así mismo una aplicación puede tener que realizar varias tareas similares por ejemplo un servidor web acepta solicitudes de los clientes que piden acceso a páginas web, imágenes, sonidos, etc., al mismo tiempo puede ser sometido a una gran carga, ya que puede tener varios o hasta miles de clientes accediendo a él de forma concurrente.

Un servidor web es un claro ejemplo de lo fundamental que son las hebras ya que de no contar con procesos multihebras solo podría dar acceso a un cliente a la vez.

[pic 1]

La hebra tiene un papel muy importante en los sistemas de llamada a procedimientos remotos (RPC) ya que normalmente los servidores son multihebra, cuando un servidor recibe un mensaje, sirve el mensaje usando una hebra específica, esto le permite al servidor dar servicio a varias solicitudes al mismo tiempo.

Hoy en día la mayoría de los kernel de sistemas operativos son multihebra; hay varias hebras operando en el kernel y cada hebra realiza una tarea específica, tal como gestionar dispositivos o tratar interrupciones. Por ejemplo, Solaris crea un conjunto de hebras en el kernel específicamente para el tratamiento de interrupciones; Linux utiliza una hebra del kernel para gestionar la cantidad de memoria libre del sistema.

Al designar una tarea en específico a una sola hebra ayuda al sistema a realizar diversas operaciones de forma simultánea ya que cuentan con varias o muchas hebras que realizar tareas diferentes y puede operar al mismo tiempo.

Modelo multihebra

El soporte para hebras puede proporcionarse en el nivel de usuario (para las hebras de usuario) o por parte del kernel (para las hebras 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 (S.O.) soporta y gestiona directamente las hebras del kernel.  Casi todos los S.O. actuales soportan las hebras de kernel.

En último término, debe existir una relación entre las hebras de usuario y las del kernel.

Modelo muchos a uno

Este asigna múltiples hebras del nivel de usuario a una hebra del kernel. La gestión de hebra se hace mediante la biblioteca de hebras en el espacio de usuario, por lo que resulta eficiente, el proceso completo se bloquea si una hebra realiza una llamada bloqueante al sistema. También dado que sólo una hebra Puede acceder al kernel y cada vez, no podrán.

[pic 2]

Modelo uno a uno

Asigna cada hebra de usuario a una hebra de kernel. Proporciona una mayor concurrencia que el anterior modelo, permitiendo que se ejecute otra hebra mientras que una hebra hace una llamada bloqueante al sistema; permite que se ejecuten múltiples hebras en paralelo sobre varios procesadores. El único inconveniente de este modelo es que crear una hebra de usuario requiere crear la correspondiente hebra del kernel por la carga de trabajo administrativa para la creación de hebras kernel.

[pic 3]

Modelo muchos a muchos

Multiplica muchas hebras de usuario sobre un número menor o igual de hebras del kernel. El número de hebras del kernel puede ser específico de una determinada aplicación o de una determinada maquina pueden asignarse más hebras del kernel a una aplicación a un sistema multiprocesador que en uno de un solo procesador. Mientras que el modelo muchos a uno permiten al desarrollador crear tantas hebras de usuario como desee, no se consigue una concurrencia real, ya que que el kernel sólo puede planificar la ejecución de una hebra cada vez. El modelo uno a uno permite una mayor concurrencia, pero el desarrollador debe tener cuidado de no crear demasiadas hebras dentro de una aplicación y en algunos casos el número de hebras qué puede crear estará limitado. El modelo mucho a muchos no sufre ningún de estos inconvenientes los desarrolladores pueden crear tantas hebras de usuario como sean necesarias y las correspondientes hebras del kernel puede ejecutarse en paralelo en un multiprocesador.

[pic 4]

Biblioteca de Hebras

Una Biblioteca de Hebras proporciona al programador una API para crear y gestionar hebras.  Existen 2 formas principales de implementar una biblioteca de hebras:

1. Proporciona una biblioteca enteramente en el espacio del usuario, sin ningún soporte del kernel.  Todas las estructuras de datos y el código de la biblioteca se encuentran en el espacio del usuario.
2. Implementa una biblioteca en el nivel del kernel, soportada directamente por el sistema operativo.  En este caso el código y las estructuras de datos de la biblioteca se encuentran en el espacio del kernel.

Las 3 principales bibliotecas de hebras actualmente en uso son:

1. POSIX Pthreads

Puede proporcionarse como biblioteca de nivel usuario o nivel cliente.

1. Win32

Es una biblioteca de nivel kernel disponible en los sistemas Windows.

1. Java Pthreads

Permite crear y gestionar directamente hebras con programa java.

Pthreads

Se basa en el estándar POSIX (IEEE 1002.1c) que define una API para a creación y sincronización de hebras.  Se trata de una especificación para el comportamiento de las hebras, no de una implementación.

Hay muchos sistemas que implementan las especificaciones Pthreads incluyendo, Solaris, Linux, Mac OS y Tru64 UNIX. También hay disponibles implementaciones de libre distribución para diversos sistemas operativos Windows.

Hebras Win32

La técnica de creación de hebras de Win32 es similar en varios aspectos a la técnica empleada en Pthreads.

Hebras Java

Son el modelo fundamental de ejecución de programas en un programa java y en el lenguaje java, su API proporciona un rico conjunto de características para la creación y gestión de hebras. Todos los programas java tienen al menos una hebra de control.

`

Consideraciones sobre las hebras.

Las llamadas al sistema fork () y exec ().

Se debe tomar en cuenta que la semántica de las llamadas al sistema fork() y exe() cambian  en los programas multihebra.

Si una hebra de un programa llama a fork (), ¿duplica todas las hebras el nuevo proceso o es un proceso de una sola hebra? Algunos sistemas UNIX han decidido disponer de dos versiones de fork (), una que duplica todas las hebras y otra que sólo duplica la hebra que invocó la llamada al sistema fork ().

Cancelación.

La cancelación de una hebra es la acción de terminar una hebra antes de que se haya completado. Por ejemplo, si varias hebras están realizando una búsqueda de forma concurrente en una base de datos y una hebra devuelve el resultado, las restantes hebras deben ser canceladas. Puede producirse otra situación de este tipo cuando un usuario pulsa un botón en un explorador web que detiene la descarga de una página web. Cuando un usuario pulsa el botón stop del navegador, todas las hebras de carga de la página se cancelan.

Una hebra que vaya a ser cancelada se denomina a menudo hebra objetivo. La cancelación c una           hebra objetivo puede ocurrir en dos escenarios diferentes:  Cancelación asíncrona y Cancelación diferida.

La asíncrona hace que una determinada hebra termine inmediatamente la hebra objetivo mientras que la diferida hace que la hebra objetivo compruebe periódicamente si debe terminar, lo que le proporciona una oportunidad de terminar por sí misma de una forma ordenada.

Tratamiento de señales

Una señal se usa en los sistemas UNIX para notificar a un proceso que se ha producido un determinado suceso. Una señal puede recibirse síncrona o asíncronamente, dependiendo del origen y de la razón por la que el suceso deba ser señalizado. Todas las señales, sean síncronas o asíncronas, siguen el mismo patrón:

1) Una señal se genera debido a que se produce un determinado suceso.

2) La seña] generada se suministra a un proceso.

3) Una vez suministrada, la señal debe ser tratada.

Como ejemplos de señales síncronas podemos citar los accesos ilegales a memoria   y la división por 0. Si un programa en ejecución realiza una de estas acciones, se genera una señal. Las señales síncronas se proporcionan al mismo proceso que realizó la operación que causó la señal (ésa es la razón por la que se consideran síncronas).

...