UNIVERSIDAD ESTATAL DE

MILAGRO
FACULTAD DE CIENCIAS DE LA
INGENIERÍA

CARRERA: INGENIERÍA EN
SOFTWARE

CURSO: CUARTO NIVEL C1

NOCTURNO

ESTUDIANTE: JOEL EDUARDO

CAMPOVERDE GONZALEZ

ASIGNATURA:
SISTEMAS OPERATIVOS

DOCENTE: JAVIER RICARDO

BERMEO PAUCAR
INTRODUCCION.
Este presente ensayo tiene el objetivo de conocer y analizar los diferentes
mecanismos de sincronización de los hilos POSIX, hablando un poco de esto, un hilo
(POSIX) permite crear programas con varios puntos de manera simultánea de
ejecución, los cuales van sincronizados a través de una memoria compartida. El uso
de estos hilos en la programación genera dificultades, la programación concurrente
(ejecución simultanea de tareas) se tiene técnicas y problemas que no ocurre en la
programación secuencial (estructura que trabaja en secuencia), existen varios
problemas más sencillos, pero hay otros que penalizan el rendimiento de un programa.
Un hilo tiene un solo flujo de control que es secuencial que es instantáneo y tiene un
solo punto de ejecución. Los programadores no tienen dificultad a la hora de
programar un solo hilo, si hay otros programas que tienen múltiples hilos eso quiere
decir que un solo programa puede tener múltiples puntos de ejecución,
DESARROLLO.

Antes de empezar hay que tener en cuenta algunos conceptos básicos.

Hilo. - Flujo de instrucciones que se puede programar para que sea ejecutado por el
sistema operativo.

POSIX. -Portable Opening System Interface (for Unix).

Concurrencia. - Describe el comportamiento de tareas de un sistema que consta

un solo procesador.

Monoprocesador. – Termino que se refiere a un ordenador con una sola unidad

visible.

Multiprocesador. - Es un ordenador con mas de dos procesadores los cuales

comparten instrucciones y entran a un mismo espacio de memoria.

Paralelismo. - Secuencias que ocurren de manera simultaneas.

Overhead. - Se define como tiempo indirecto el cual es necesario para que se lleve
a cabo una ejecución.

DESCRIPCION DE HILOS POSIX.

Es un estándar orientado a facilitar la creación de aplicaciones seguras y portables,

son API de subprocesos C/C++, que permite la creación de un flujo nuevo de
procesos concurrente. La biblioteca para el manejo de hilos en POSIX es pthread.
 CREACION DE HILOS POSIX. (“pthread__create”).

Permite establecer de manera rápida un hilo cuando ya está preparado.

En algunas veces nos puede presentar un valor de retorno de cero si es que existió
y de no ser así se presentara con un valor negativo. (“pthread_attr_init/destroy”)

# include <pthread.h>
int pthread_create (pthread_t * restrict tidp: salida, puntero a id del hilo
tidp, attr: entrada, para definir atributos del hilo, null para
const pthread_attr_t * restrict attr, default
void * (* start_routine) (void *), start_routine: entrada, función con que corre el hilo
void * restrict arg); 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
ATRIBUTOS DE HILOS POSIX.

Algunos de sus atributos más relevantes son:

Detachstate: examina si otro hilo lograra esperar por la terminación de este hilo en el
cual se encarga pthread_joing.

PTHREAD_CREATE_JOINABLE (defecto).

PTHREAD_CREATE_DETACHED.

Schedpolicy: este es el ayuda a vigilar la aplicación del hilo.

SCHED_OTHER (valor por defecto, planificación normal+no tiempo real).

SCHED_RR (round robin+tiempo real+privilegios root).

SCHED_FIFO (first in first out+tiempo real+privilegios root).

 Scope: en este se verifica el nivel en el cual está registrado el hilo.

PTHREAD_SCOPE_SYSTEM (defecto, este es un hilo reconocido por el núcleo).

PTHREAD_SCOPE_PROCESS (este no es sobrellevado en lo que es la

implementación de LinuxThreads de hilos POSIX).

IDENTIFICACION DE HILOS.

Así como un proceso tiene un PID (Process Identification), cada hilo tiene un
identificador de hilo. Mientras los PID son enteros no negativos, el ID de un hilo es
dependiente del SO y puede ser una estructura. Por esto para su comparación se

usa una función.

#include <pthread.h> Compara dos identificados de hilos tid1 y tid2
int pthread_equal (pthread_t tid1, pthread_t 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ó

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>
void pthread_exit (void *status);
 DETACHING Y JOINING EN HILOS (DESASOCIACION 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 tid); al término del hilo con tid, sus recursos serán
retornados
y llamados a pthread_join arrojan error.

(pthread_join) ESPERAR POR LA TERMINACIÓN DE UN HILO.

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.

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.
 #include <pthread.h>
int pthread_join (pthread_t tid, void **status);

(pthread_cancel). CANCELACIÓN DE UN HILO.

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 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).

#include <pthread.h>
int pthread_cancel (pthread_t tid);
EJERCICIO DE APLICACION.

Comparación entre creación de procesos y creación de hilos.

C Code for fork () creation test

===========================================================================
===
#define NFORKS 50000

void do_nothing () {
int i;
i= 0;
}

main () {
int pid, j, status;

for (j=0; j<NFORKS; j++) {

/*** error handling ***/

if ((pid = fork ()) < 0) {
printf ("fork failed with error code= %d\n", pid);
exit (0);
}

/*** this is the child of the fork ***/

else if (pid ==0) {
do_nothing ();
exit (0);
}

/*** this is the parent of the fork ***/

else {
waitpid (pid, status, 0);
}
}
}
===========================================================================
===
C Code for pthread_create () test
===========================================================================
===
#include <pthread.h>

#define NTHREADS 50000

void *do_nothing (void *null) {

int i;
i=0;
pthread_exit (NULL);
}

main () {
int rc, i, j, detachstate;
pthread_t tid;
pthread_attr_t attr;

pthread_attr_init(&attr);
pthread_attr_setdetachstate (&attr, PTHREAD_CREATE_JOINABLE);

for (j=0; j<NTHREADS; j++) {

rc = pthread_create (&tid, &attr, do_nothing, NULL);
if (rc) {
printf ("ERROR; return code from pthread_create () is %d\n", rc);
exit (-1);
}

/* Wait for the thread */

rc = pthread_join (tid, NULL);
if (rc) {
printf ("ERROR; return code from pthread_join () is %d\n", rc);
exit (-1);
}
}
pthread_attr_destroy(&attr);
pthread_exit (NULL);

}
CONCLUSION.

La finalidad de esta investigación tuvo la finalidad de poder ampliar los

conocimientos acerca de este tema (hilos POSIX) aprender conceptos básicos sobre
Hilos, experimentar con los llamados hilos de POSIX, conocer los mecanismos de
sincronización de POSIX, identificar y analizar su creación, atributos, como eliminar y
conceptos básicos. El propósito y uso de estos hilos es de usar una biblioteca de
subprocesos POSIX en un software esta en la manera de ejecutar y hacer que el
software sea mas rápido. Para que sea posible escribir programas con hilos
portátiles, como hemos visto anteriormente en la arquitectura de los
multiprocesadores y multinúcleos de memoria que están compartida, en los cuales
se utilizan los subprocesos para poder implementar lo que llamamos paralelismo, la
preocupación de los programadores es la portabilidad lo que provocó la creación de
la interfaz POSIX.

Muchos sistemas operativos son compatibles con POSIX lo cual ha sido

especificada por los estándares IEEE POSIX1003.1c, su implementación es
adquiridas a estos estándares. Este documento habla y se describe desde como se
crea un hilo y su cancelación.

Para finalizar estos estándares permite la generación de un flujo de procesos

concurrentes, además es más eficaz en sistemas de procesamiento múltiple don de
el flujo del proceso se puede programar para que se ejecute en otro procesador,
ganado así velocidad a través del procesamiento paralelo o distribuido.
Bibliografía
http://profesores.elo.utfsm.cl/~agv/elo330/2s08/lectures/POSIX_Threads.html

https://es.acervolima.com/diferencia-entre-hilos-primordiales-y-no-primordiales/

https://www.infor.uva.es/~fdiaz/so/2005_06/doc/SO_PR06_20041130.pdf

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

https://www.infor.uva.es/~fdiaz/so/2004_05/doc/SO_PR05_20041026.pdf

https://bibliotecavirtualda.com/wp-content/uploads/2021/08/2Taller-de-programacion-
concurrente.pdf