Repasando…..

• Un proceso es un programa en ejecución.

• Un proceso necesita recursos para poder ejecutarse: memoria, dispositivos
de E/S, la CPU, etc.
• En la organización de un proceso, sus áreas típicas de la memoria son:
código, datos y pila.

Los estados de un proceso pueden ser:

• nuevo
• ejecutando
• bloqueado
• listo
• terminado

Cada proceso tiene un Bloque de Control de Proceso (PCB) que almacena el

estado e información de control, de memoria, registros, planificador, etc.
 Procesos – Theads (hilos)
Un hilo, hebra o proceso ligero es una unidad básica de ejecución, es una línea
de ejecución de un proceso. Todo proceso parte inicialmente con un único hilo
principal, aunque el sistema operativo ofrece llamadas al sistema que permiten al
programador crear y destruir hilos. Un proceso está compuesto por uno o más
hilos.
Tienen elementos propios:
Contador de programa Registros de CPU
Pila (stack) Estado

Los hilos dentro de una misma aplicación comparten:

Espacio de direcciones Variables globales
Archivos abiertos Procesos hijos
Alarmas pendientes Señales y manipuladores de señales
Información de contabilidad etc.
Un proceso pesado (simplemente llamado proceso o tarea) puede contener
uno o varios hilos que comparten la misma memoria y recursos y es una
aplicación, mientras que los hilos son actividades concurrentes dentro de esa
aplicación
 Beneficios y características del multithreading
• Es mucho más rápido crear y finalizar un hilo que un proceso
• Lleva menos tiempo cambiar entre 2 hilos del mismo proceso (porque los recursos
se comparten)
• Mejoran la comunicación en el programa que se está ejecutando ya que al
compartir la memoria y archivos, no es necesaria invocar a núcleo para esto.
• Simplifican la estructura de un programa al hacerlo más modular donde cada hilo
realiza una tarea en particular.
• Etc.
En multithreading, todos los hilos tienen
los mismos privilegios y comparten la
memoria (heap, variables globales, y
código) y por otro lado, cada hilo tiene
su propio bloque de control de hilo
(TBC) (contiene valores de los
registros, la prioridad, y otra infor-
mación relativa al estado del hilo (id,
estado, política de sincronización,
etc.)). Un hilo puede acceder al estado
de otro hilo
 Threads
Algunos ejemplos de uso:
• Trabajo en primer plano y en segundo plano (ej. Un hilo puede mostrar la
interface de una aplicación mientras otro realiza los cálculos).
• Procesamiento asíncrono. (ej. crear una copia de seguridad mientras otro sigue
leyendo el teclado).
• Velocidad de ejecución. (ej. Se puede ejecutar un lote de datos mientras otro hilo
lee el lote siguiente de un dispositivo.).
• Estructura modular de programas. (ej. los programas se pueden diseñar e
implementar más fácilmente usando hilos separando las actividades)
• Etc.
Observación:
En un sistema operativo que soporte hilos, la planificación y la activación se
realizan a nivel de hilo por lo que la mayor parte de la información se mantiene
en el bloque de control de hilo.
Hay acciones que afectan a todos los hilos de un proceso, como por ejemplo un
cambio de contexto o terminación del mismo ya que desasigna el espacio de
direcciones utilizado y como todos los hilos lo comparten, todos los hilos se
suspenden o terminan al mismo tiempo.,
 Estado y operaciones de un hilo
Los estados (al igual que los procesos) son :
• En ejecución: está en ejecución en un procesador
• Listo : está preparado para ejecutar, pero aún no tiene un procesador disponible
Finalización
• Bloqueado: esperando a una condición para poder continuar ejecutando
En
Las operaciones relacionadas con los hilos asociadas al cambio de estado son:
ejecución
• Creación: Cuando se crea un nuevo proceso, también se crea un hilo de dicho
proceso. Este hilo puede crear otros dentro del mismo proceso dándoles punteros
Planificación Bloqueo
al código y argumentos. Este nuevo hilo tendrá su propio registro de contexto y
(o suspensión)
espacio de pila y se colocaExpulsión
en la cola de Listos.
• Bloqueo. Cuando un hilo necesita esperar por un evento se bloquea, almacenando
Creación
los registros de usuario, contador de programa y punteros de pila. El procesador
puede pasar a ejecutar otro hilo en estado Listo, dentro del mismo proceso o en
otro diferente. Listo
Bloqueado
• Desbloqueo. Cuando sucede el evento por el que el hilo está bloqueado, el hilo se
pasa a la cola de Listos.
• Planificación y expulsión son operaciones Desbloqueo llevadas a cabo de acuerdo a las politicas
(o activación)
de planificación
• Finalización. Cuando se completa un hilo, se liberan su registro de contexto y pilas.
 Diferentes diseños de procesos e hilos
Con multithreading (multihilo) se refiere a la capacidad de un sistema
operativo de dar soporte a múltiples hilos de ejecución en un solo proceso.

MS-DOS Java,
Monopro-
cesadores
Un hilo por proceso Múltiples hilos por proceso
Un proceso Un proceso

UNIX – NT, Solaris,

Multiproce- versiones Linux,
sadores iniciales OS/2,
Un hilo por proceso Trix, etc
Múltiples procesos
Múltiples hilos por proceso
Múltiples procesos

Técnica Monohilo Técnica Multihilo

Espacio de
Hilo
Direcciones
Categorías en la implementación de hilos 1/3 (Stallings 165)
(Tanenbaum2.2.4)

Hilos a nivel de usuario (ULT user level thread):

Todo el trabajo de gestión de hilos (crear, destruir, intercambiar mensajes y datos, planificar,
guardar y recuperar contexto de hilos, etc) lo realiza la aplicación (generalmente por medio
de una librería o bibliotecas). Todas las operaciones se realizan en el espacio del usuario de
un mismo proceso. El kernel continua planificando el proceso como una unidad y
asignándole un único estado (listo, bloqueado, etc.) y no es consciente de la existencia de
los hilos.
Ejemplo de ULT: pthreads de POSIX.
Ventajas:
• Más rápidos porque no requieren system call
• Para cambiar de hilo no en necesario privilegios del modo kernel ( todas las estructuras de
datos están en el espacio de direcciones de usuario de un mismo proceso.)
• De acuerdo a algún criterio y la aplicación puede seleccionar una planificación específica.
• Se pueden ejecutar en cualquier sistema operativo. (están en una librería)
Desventajas:
• Cuando un hilo realiza una llamada al sistema, se bloquea el mismo y también el resto de
los hilos del proceso (generalmente los system call son bloqueantes (esperan a que
devuelta un resultado))
• Como el procesador ve al proceso multihilo como uno solo por los que no aprovecha las
ventajas de multiprocesamiento.
Categorías en la implementación de hilos 2/3 (Tanenbaum2.2.5)

Hilos a nivel de kernel (KLT kernel level thread):

Todo el trabajo de gestión de hilos lo realiza el kernel (planificación, sincronización, cambio,
etc). En el área de la aplicación no hay código de gestión de hilos, únicamente un API
(interfaz de programas de aplicación) para la gestión de hilos en el núcleo. Este método es
utilizado en Windows 2000, Linux y OS/2.
Ventajas:
• El kernel puede planificar simultáneamente múltiples hilos del mismo proceso en múltiples
procesadores.
• Si se bloquea un hilo, puede planificar otro del mismo proceso o de otro proceso
• Las propias funciones del kernel pueden ser multihilo.
Desventajas:
• El paso de control de un hilo a se realiza accediendo al núcleo..

(Tanenbaum2.2.6)
Puede aproximaciones combinadas de ULT y KLT, por ejemplo algunas distribuciones de
Linux como Ubuntu y Fedora y derivados de UNIX como Solaris.
En un método combinado
• Creación, sincronización y planificación de hilos de una aplicación en modo usuario.
• Planificación de múltiples hilos de un proceso en múltiples procesadores.
• El bloqueo de un hilo no supone (necesariamente) bloquear todo el proceso. y las llamadas
al sistema bloqueantes no necesitan bloquear todo el proceso.
 Categorías en la implementación de hilos 3/3
Resumiendo se puede ver gráficamente:

Stallings 166. Hilos de nivel de usuario y de nivel de núcleo

Link interesante: https://hpc.llnl.gov/training/tutorials

 Manejo de Hilos en C (POSIX)
En 1995 se adopto la norma IEEE POSIX (Portable Operating System Inferface), que define
un a interfaz estándar del sistema operativo y su entorno. Permite manipular threads en los
programas.

Para utilizar hilos en Linux debe utilizar la librería:

#include <pthread.h>
En las opciones de compilación se deberá agregar:

-lpthread
 Manejo de Hilos en C (POSIX)
En un proceso POSIX convencional:
• Existe un hilo inicial que ejecuta la función main()
• Este hilo puede crear más hilos para ejecutar otras funciones dentro del espacio de
direcciones del proceso.
• Todos los hilos de un proceso se encuentran al mismo nivel. „ (Esto significa que son
“hermanos”, a diferencia de los proceso cuya relación es “padre-hijo”)
• Se dice que un hilo es dinámico si se puede crear en cualquier instante durante la
ejecución de un programa
• Los hilos de un proceso comparten las variables y recursos globales (archivos,
manejadores de señales, etc.) del proceso. Además, cada uno tiene una copia privada de
sus parámetros iniciales y de las variables locales de la función que ejecuta (almacenados
en su pila particular).

„ El estándar POSIX define, entre otras, funciones para:

• „Creación de hilos
• Creación/destrucción de atributos de creación de hilos
• Terminación/espera a la terminación de un hilo
• Identificación de hilos
https://computing.llnl.gov/tutorials/pthreads/#Abstract
 Creación de Hilos en C (create)
Crea inmediatamente el hilo en estado listo, por lo que el hilo creado y su hilo creador entran
a competir por la CPU de acuerdo a la política de planificación.
Cualquier hilo puede crear otro, no solamente el principal.
Sintaxis:
int pthread_create(pthread_t *thread,
const pthread_attr_t *attr,
void *(* start_routine)(void *), void *arg)
attr es el atributo que contiene las características
del hilo creado .
„ start_routine es la función que ejecutará el
hilo (es decir la dirección donde el hilo se va a
ejecutar).
„ arg es un puntero a los parámetros iniciales del
hilo
„ En thread se devuelve el identificador del hilo
creado si la llamada tiene éxito
Valor de retorno:
„ 0 si éxito y un valor negativo si hay error
 Terminación de Hilos en C (exit)
Un hilo puede finalizar por diferentes motivos:
• Implícitamente: cuando terminó el código del hilo
• Explícitamente: cuando desde el código se utiliza la función pthread_exit()
• Al invocar el comando exit() con lo cual finaliza el proceso y todos los hilos creados por éste.
Sintaxis:
void pthread_exit (void* thread_return)
• thread_return : es un puntero de tipo void* (generalmente NULL cuando no se
devuelve nada)
• Si en el hilo principal, se invoca a
pthread_exit(), se esperará la
finalización de todos los hilos.
• Si el hilo es sincronizable (joinable) el
identificador del hilo y su valor de
retorno puede examinarse por otro hilo
mediante la invocación a pthread_join
a través del parámetro
thread_return
• La finalización del último hilo de un
proceso finaliza la ejecución del
proceso
 Atributos de hilos 1/2
Con „ pthread_attr_init/destroy: se manipulan los atributos de un hilo
„Sintaxis:
int pthread_attr_init(pthread_attr_t * attr);
int pthread_attr_destroy(pthread_attr_t * attr);
„ pthread_attr_init inicializa el objeto de atributos de un hilo attr y establece los valores por
defecto. „ Posteriormente, este objeto, con los atributos por defecto de un hilo, se
puede utilizar para crear múltiples hilos .
„ pthread_attr_destroy, destruye el objeto de atributos de un hilo attr, y éste no puede
volver a utilizarse hasta que no se vuelva a inicializar

Algunos atributos (más relevantes) de un hilo POSIX:

„detachstate: controla si otro hilo podrá esperar por la terminación de este hilo (mediante la
invocación a pthread_join):
„ PTHREAD_CREATE_JOINABLE (valor por defecto)
„ PTHREAD_CREATE_DETACHED
„ schedpolicy: controla cómo se planificará el hilo
„ SCHED_OTHER (valor por defecto, planificación normal + no tiempo real)
„ SCHED_RR (Round Robin + tiempo real + privilegios root)
„ SCHER_FIFO (First In First Out + tiempo real + privilegios root)
„ scope: controla a qué nivel es reconocido el hilo
„ PTHREAD_SCOPE_SYSTEM (valor por defecto, el hilo es reconocido por el
 Atributos de hilos 2/2
„Con pthread_attr_set/getxxxxx: se pueden establecer o consultar atributos particulares de
un objeto con los atributos de un hilo
Sintaxis:
int pthread_attr_setdetachstate (pthread_attr_t *attr,
int detachstate);

int pthread_attr_getdetachstate (const pthread_attr_t *attr,

int *detachstate);

int pthread_attr_setschedpolicy (pthread_attr_t *attr,

int policy);

int pthread_attr_getdetachstate (const pthread_attr_t *attr,

int *policy);

int pthread_attr_setscope (pthread_attr_t *attr,

int contentionscope);
int pthread_attr_getscope (const pthread_attr_t *attr,
int *contentionscope);
 Espera la ejecución de hilos
Sintaxis:
int pthread_join(pthread_t tid, void **status);

Descripción
Esta función suspende la ejecución del hilo que la invoca hasta que el hilo identificado por el
valor tid finaliza, bien por la invocación a la función pthread_exit o por estar cancelado.
Si status no es NULL, el valor devuelto por el hilo (el argumento de la función
pthread_exit, cuando el hilo hijo finaliza) se almacena en la dirección indicada por
status.
El valor devuelto es o bien el argumento de la función pthread_exit o el valor
PTHREAD_CANCELED si el hilo tid está cancelado (o el valor en el return de la función)
El hilo por el que se espera su terminación debe estar en estado sincronizable (joinable state)
• „Cuando un hilo en este estado termina, no se liberan sus propios recursos (descriptor
del hilo y pila) hasta que otro hilo espere por él
• La espera por la terminación de un hilo para el cual ya hay otro hilo esperando, genera
un error
 Cancelación de hilos
Sintaxis:
int pthread_cancel(pthread_t tid);
Descripción
• La cancelación es el mecanismo por el cual un hilo puede solicitar la terminación de la
ejecución de otro
• Dependiendo de la configuración del hilo al que se solicita su cancelación, puede aceptar
peticiones de cancelación (PTHREAD_CANCEL_ENABLE, estado por defecto) o
rechazarlas (PTHREAD_CANCEL_DISABLE)
Ej. cambio atributo: pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, NULL);
• En caso de aceptar peticiones de cancelación, un hilo puede completar la cancelación de
dos formas diferentes:
• De forma asíncrona (PTHREAD_CANCEL_ASYNCHRONOUS),: Se cancela
inmediatamente o
• De forma diferida (PTHREAD_CANCEL_DEFERRED, valor por defecto) hasta que
se alcance un punto de cancelación.
• Un punto de cancelación (cancelation point) es un punto en el flujo de control de
un hilo en el que se comprueba si hay solicitudes de cancelación pendientes.
• Cuando un hilo acepta una petición de cancelación, el hilo actúa como si se hubiese
realizado la siguiente invocación pthread_exit(PTHREAD_CANCELED)
 Identificación de hilos
A veces es necesario obtener que thread está ejecutando cierta parte de un código.

Sintaxis:
pthread_t pthread_self(void);
int pthread_equal(pthread_t tid1, pthread_t tid2);

Descripción
• „ La función pthread_self devuelve el identificador de hilo (tid, thread identifier) del hilo
que la invoca
• „ Para comparar diferentes identificadores de hilo debe utilizarse la función
pthread_equal que:
• „ Devuelve 0 si los identificares no son iguales
• „ Otro valor si los identificadores sí son iguales)

Con estas funciones se puede por ejemplo controlar de antemano la posibilidad de hacer un
pthread_join sobre uno mismo.
Ejemplo 1
Ejemplo 2
Ejemplo 3
Ejemplo 4
Ejemplo 5