UNIVERSIDAD ESTATAL DE MILAGRO

TECNOLOGÍAS DE LA INFORMACION Y COMUNICACIÓN EN LINEA

AULA:
C2
ESTUDIANTE:

ESTEFANIA MISHEL TAPIA ESPINOSA

ASIGNATURA:

SISTEMAS OPERATIVOS

DOCENTE:
JAVIER RICARDO BERMEO PAUCAR

TEMA DEL TALLER:

CONOCER Y ANALIZAR LOS DIFERENTES MECANISMOS DE SINCRONIZACIÓN DE
LOS HILOS POSIX PARA CONTRIBUIR A SU CONOCIMIENTO A TRAVÉS DE LA
PRÁCTICA CON SUS OPERACIONES.

FECHA DE ENTREGA:

Miércoles 11 de enero del 2023

PERÍODO:

NOVIEMBRE 2022 MARZO 2023

MILAGRO – ECUADOR
 II

INDICE GENERAL

Introducción ............................................................................................................................. III

Desarrollo................................................................................................................................ IV
Hilos Posix Descripción............................................................................................................. V
Creación de Hilos ................................................................................................................. V
Conc eptos de hilo o hebra: ................................................................................................VI
Administración de Hilos:................................................................................................ VII
Atributos .................................................................................................................... X
Atributos (má s relevantes) de un hilo POSIX: ................................................................. XI
 PTHREA D_CREA TE _DE TA CHED ............................................................................. XI
Hilos POSIX (pthreads): terminación.......................................................................................................XI
Hilos POSIX (pthreads): espera por terminación ................................................................... XII
Conclusión............................................................................................................................................ XIV
ANEXOS ..................................................................................................................................................XV
Bibliografía ........................................................................................................................................... XVI
 III

Introducción

Los distintos hilos de ejecución comparten una serie de recurso tales como el
espacio de memoria los archivos abiertos, situación de autenticación, etc.

Esta técnica permite simplificar el diseño de una aplicación que debe llevar a
cabo distintas funciones simultáneamente.

Discutiremos los estándares POSIX, que intentan estandarizar las API de UNIX
de uso común. Una de estas reglas se aplica al sujeto. El estándar es tan
conocido que tiene un nombre especial, Pthreads. Sin embargo, fuera de UNIX,
las bibliotecas POSIX están disponibles en muchos sistemas operativos debido
a la gran cantidad de programas implementados con estas llamadas al sistema
API. Puede recordar que incluso Windows NT tiene una biblioteca para manejar
algunas llamadas al sistema API POSIX en el nivel del código fuente. Debido a
esta amplia disponibilidad, las cadenas POSIX tienen un nicho real: brindan una
aplicación altamente portátil. El estándar es tan conocido que el compilador IBM
Fortran incluso tiene una implementación de subprocesos. Sin embargo, tenga
en cuenta que POSIX no es un paquete sino un estándar. Cada desarrollador
puede implementar servicios como mejor le parezca.
 IV

Desarrollo

Para empezar, primero debemos describir algunos conceptos importantes

Hilo: Se puede programar un subproceso de instrucciones para que el

sistema operativo las ejecute. Esta es la unidad de procesamiento más
pequeña que puede ejecutar un programa de sistema operativo,
también conocido como proceso ligero.

Asíncronia/Asincronismo: Centrarse en eventos que son independientes

entre sí.

Concurrencias: Describe el comportamiento de las tareas en un sistema de

un solo procesador. Parecen estar sucediendo al mismo tiempo. Pero
en términos de implementación, es consistente.

CPU : este término se refiere a una computadora que tiene un solo

bloque visible para el programador.

Multiprocesador: Esta es una computadora con más de dos

procesadores que comparten instrucciones y comparten el mismo espacio
de memoria.

Paralelismo: Son secuencias concurrentes, es decir, procesos

que realizan dos o más cálculos al mismo tiempo.

Overhead: se define como el tiempo intermedio requerido para completar la

ejecución.
 V

HILOS POSIX DESCRIPCIÓN

En POSIX, los procesos funcionan de la manera habitual: hay un hilo que ejecuta una
función, ese hilo tiene la capacidad de crear hilos adicionales para ejecutar
otros hilos que residirán en el espacio de direcciones del proceso. Todos
estos subprocesos estarán en el mismo nivel, lo que significa que son "hermanos", a
diferencia de otros procesos que están relacionados entre padres e hijos.

CREACIÓN DE HILOS

Hemos visto procesos y algunas formas de intercambiar información entre procesos.

Ahora veremos cómo usar algunas correas o transmisiones de control para realizar
algunas tareas en el mismo proceso. Un aspecto ineludible cuando se habla de
compartir recursos son los mecanismos de sincronización necesarios
para mantener la consistencia de los recursos compartidos.

OBJETIVOS: aprender los conceptos básicos de los subprocesos, experimentar

con llamadas de subprocesos POSIX, aprender el mecanismo de
sincronización POSIX. POSIX significa Interfaz de sistema operativo portátil
(para Unix). Es un estándar diseñado para facilitar la creación de
aplicaciones potentes y portátiles. La mayoría de las versiones populares de Unix
(Linux, Mac OS X) cumplen en gran medida este estándar. Biblioteca de prostix - Flow
Pthread.
 VI

CONCEPTOS DE HILO O HEBRA:

Un proceso típico de Unix se puede considerar como un único flujo de control: cada
proceso solo realiza una operación a la vez. Con múltiples hilos
de control, podemos hacer muchas cosas al mismo tiempo, y cada hilo se ocupa de
una tarea.

Beneficios de Hilos:

 Puede manejar eventos asincrónicos especificando un subproceso para cada

tipo de evento.
 Los hilos del proceso tienen la misma dirección y describen el archivo.
 Los procesos con muchas tareas independientes pueden terminar antes
si estas tareas superponen subprocesos separados.
 Los programas interactivos pueden lograr mejores tiempos de
respuesta mediante el uso de subprocesos para procesar la entrada y la salida
 Crear un hilo es mucho más rápido y requiere menos recursos que crear un
proceso.

Multi hilos:

se refiere a máquinas con uno o más procesadores. Un hilo incluye la información

necesaria para representar el contexto de la aplicación en el proceso

 Stack pointer
 Registros
 Propiedades de itineración (como política y prioridad)
 Conjunto de señales pendientes y bloquedas.
 Datos específicos del hilo.
 VII

Administración de Hilos:

Un paquete de manejo de hilos generalmente incluye funciones para: crear y destruir

un hilo, itineración, forzar exclusión mutua y espera condicionada. Los hilos de un
proceso comparten variables globales, descriptores de archivos abiertos, y puede
cooperar o interferir con otros hilos.

Todas las funciones de subprocesos POSIX comienzan con pthread.

 VIII

Función POSIX Descripción (páginas man, otra)

pthread_equal verifica igualdad de dos identificados de hilos

pthread_self retorna ID de propio hilo (similar a getpid)

pthread_create crea un hilo (similar a fork)

pthread_exit termina el hilo sin terminar el proceso (similar a exit)

pthread_join espera por el término de un hilo (similar a waitpid)

pthread_cancel Termina otro hilo (similar a abort)

pthread_detach Configura liberación de recursos cuando termina

pthread_kill envía una señal a un hilo

Para hacer uso de estas funciones incluir <pthread.h>

IDENTIFICACIÓN DE HILOS:

Al igual que un proceso tiene un PID (Identificación de Proceso). Cada subproceso tiene
un identificador de subproceso. Aunque el PID es un número entero no negativo, el ID
del subproceso depende del sistema operativo y puede ser una estructura, por lo que
se utiliza una función para la comparación.

#include <pthread.h> Compara dos identificados de hilos tid1 y

int pthread_equal(pthread_t tid1, pthread_t tid2); tid2
Retorna: no cero si es igual, cero en otro caso
#include <pthread.h> Para obtener identificador de un hilo
pthread_t pthread_self(void);
Retorna: la ID del hilo que la llamó
 IX

CREACIÓN DE HILOS

Los procesos normalmente corren como un hilo único. La creación de un nuevo hilo se
logra vía pthread_create.
# include <pthread.h>
int pthread_create(pthread_t *
restrict tidp,
const pthread_attr_t * restrict attr,
void * ( * start_routine ) (void *),
void * restrict arg);
tidp: salida, puntero a id del hilo
attr: entrada, para definir atributos del hilo, null para
default
start_routine: entrada, función con que corre el hilo
arg: entrada, argumento de la función del hilo.
la función debe retornar un * void, el cual es
interpretado
como el estatus de término por pthread_join

Ejemplo: Impresión de thread ID. Puede bajar todos los fuentes del texto guía, una
mirada al Makefile es educativa, se aprende a crear una biblioteca, y cómo generar
una compilación parametrizada por la plataforma en que usted trabaje.

Término de un Hilo:
Si un hilo invoca a exit, _Exit o _exit, todo el proceso terminará.
Un hilo puede terminar de tres maneras sin terminar el proceso: Retornando de su
rutina de inicio, cancelada por otro hilo del mismo proceso, o llamando pthread_exit.

#include <pthread.h> rval_ptr queda disponible para otros hilos

void pthread_exit (void *
rval_ptr);
int pthread_join(pthread_t tid,
void ** rval_ptr);
int pthread_cancel(pthread_t tid);
int pthread_setcacelstate(int
state, int * oldstate);
al llamar pthread_join
rval_ptr debe existir después del término
del hilo.
El hilo llamante se bloquea hasta el término
del hilo indicado.
Si el hilo en cuestión es cancelado, rval_prt
toma el valor
PTHREAD_CANCELED
Si no estamos interesados en el valor
retornado, poner NULL.
Retorno 0 es OK, !=0 => error.
Equivale a si el hilo indicado llamara
pthread_exit(PTHREAD_CANCELED); sin
embargo, un hilo puede
ignorar este requerimiento o controlar cómo
se cancela.
pthread_cancel sólo hace un requerimiento,
pero no lo fuerza.
Permite cambiar el estado del hilo a
PTHREAD_CANCEL_ENABLE (default) o
 X

PTHREAD_CANCEL_DISABLE, en este
estado el hilo ignora
llamados a pthread_cancel.

Detaching y Joining en hilos (desasociar y reunión)

Todo hilo ocupa recursos del SO para su operación. Entre ellos se encuentra el
estatus de término el cual es retenido hasta el llamado a pthread_join; sin embargo,
los recursos ocupados por un hilo pueden ser retornados inmediatamente después
que éste termina si llamamos a pthread_detach. En este caso un llamado a
pthread_join fallará y retornará EINVAL.

#include <pthread.h> retorna 0 es OK, !=0 => error.

int pthread_detach(pthread_t al término del hilo con tid, sus recursos serán
tid); retornados
y llamados a pthread_join arrojan error.

ATRIBUTOS

pthread_attr_init/destroy: Manipulación atributos de un hilo

DESCRIPCIÓN

 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 inicializa.
 XI

ATRIBUTOS (MÁS RELEVANTES) DE UN HILO POSIX:

detachstate: controla si otro hilo podrá esperar por la terminación de

estehilo (mediante la invocación apthread_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
núcleo)
PTHREAD_SCOPE_PROCESS (no soportado en la implementación
LinuxThreads de hilos POSIX)

HILOS POSIX (PTHREADS): TERMINACIÓN

pthread_exit: Terminación de un hilo

DESCRIPCIÓN

 pthread_exit finaliza explícitamente la ejecución del hilo que la invoca

la finalización de un hilo también se hace cuando finaliza la ejecución de
las instrucciones de su función.
 La finalización del último hilo de un proceso finaliza la ejecución del
proceso siel 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 status.
 XII

HILOS POSIX (PTHREADS): ESPERA POR TERMINACIÓN

pthread_join: Esperar por la terminación de un hilo

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 indicadapor 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
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.
 XIII

Hilos POSIX (pthreads): cancelación

pthread_cancel: Solicitar la cancelación de un hilo.

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)

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), 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 deun 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 sehubiese realizado la siguiente
invocación pthread_exit(PTHREAD_CANCELED)
 XIV

CONCLUSIÓN

Los hilos, también conocidos como procesos ligeros (o pthread en inglés), se

pueden considerar como la unidad básica de ejecución de un proceso, es decir,

que representan una pieza de código que se procesa o se procesará en un

momento exacto. El uso de subprocesos en un proceso permite que piezas de

código (que pueden o no ser iguales) se ejecuten simultáneamente, lo que

reduce el tiempo necesario para hacer lo que se requiere y sin tener que crear

las estructuras de datos necesarias en ese momento. tiempo de ejecución,

creación de procesos, porque los hilos tienen cosas en común. También puede

decir que los subprocesos aumentan la eficiencia de la comunicación entre los

programas en ejecución, también durante nuestra investigación nos dimos

cuenta de que existe un programa de subprocesos múltiples que se puede

ejecutar en paralelo o simultáneamente de forma independiente con el sistema.

Además, algunos lenguajes de programación tienen características de diseño

explícitas que permiten a los programadores trabajar con subprocesos como

Java o Delphi. También podemos decir que los subprocesos pasan por diferentes

estados como nuevo, preparado, en ejecución, bloqueado, inactivo, pendiente,

completado. Algunos de los beneficios que podemos obtener de la programación

de subprocesos es la capacidad de manejar múltiples eventos de forma

asíncrona especificando un subproceso para cada tipo de evento. Los

subprocesos de un proceso comparten el mismo espacio de direcciones y el

mismo descriptor de archivo. Crear un hilo es mucho más rápido y requiere

menos recursos que crear un proceso. Al igual que un proceso tiene un PID (que

identifica el proceso), cada subproceso tiene una ID de subproceso.

 XV

ANEXOS

EJERCICIO PRÁCTICO
 XVI

BIBLIOGRAFÍA

Barney, B., & Lawrence Livermore National Laboratory. (n.d.). POSIX threads

programming. LLNL HPC Tutorials. Retrieved January 4, 2023, from

https://hpc- tutorials.llnl.gov/posix/

Hilos de ejecución POSIX. (n.d.). Uva.Es. Retrieved January 4, 2023, from

https://www.infor.uva.es/~fdiaz/aso/2005_06/doc/ASO_PR01_20060228.pdf

#:~:text=

Hilos%20POSIX%20%28pthreads%29%20%C2%84%20Dentro%20de%20u

n%20pr

oceso,de%20un%20proceso%20se%20encuentran%20al%20mismo%20niv

el

Mt1014, E. /., Operativos, S., Ma, ©., & Castaño, A. (n.d.). Concurrencia entre

procesos 1.

Uji.Es. Retrieved January 4, 2023, from

https://repositori.uji.es/xmlui/bitstream/handle/10234/171556/TrasparenciasT

ema3.p df?sequence=1&isAllowed=y

Servicios POSIX para gestión de hilos. (2016, October 1). Sistemas Operativos

#1. https://sisoperativoutp1995.wordpress.com/2016/10/01/servicios-posix-

para-gestion- de-hilos/
 XVII

Rodríguez García, J. M., Díaz Martín, J. C., & Irala Veloso, I. (1999). Programación

concurrente basada en hilos Posix. Asociación de Enseñantes Universitarios

de la Informática (AENUI).

Pimentel, A., & Jesús, J. (2018). Explorando tres niveles de paralelismo empleando

software libre y freeware en computadoras personales multicore. El caso de

Linux versus Windows. http://repositorio.utm.mx/handle/123456789/153