Ingeniería software

Modalidad:
Presencial

Asignatura:
Sistemas operativos

Docente:
Javier Bermeo
Estudiante:
Eddie Game

Tema:
Tarea2(HILOS POSIX)
Curso:
w- 306

Tercer semestre

1
Contenido
Introducción ....................................................................................................... 3
Desarrollo del tema ........................................................................................... 4
Hilos POSIX..................................................................................................... 4
Conceptos importantes ..................................................................................... 5
Creación de hilos ............................................................................................... 5
Creación de hilos en diferentes entornos ....................................................... 6
Atributos ............................................................................................................. 8
Terminación de hilo ........................................................................................... 8
Espera por la terminación de un hilo ............................................................... 9
Cancelación de un hilo ...................................................................................... 9
Ejemplo ............................................................................................................. 10
Conclusión ....................................................................................................... 11
Bibliografias ..................................................................................................... 12

2
 Introducción

Los "Hilos POSIX" son una parte fundamental en el ámbito de la programación y la

informática que nos permite adentrarnos en el mundo de la concurrencia. Estos hilos,
o subprocesos, son unidades de ejecución más pequeñas que los procesos
principales en un sistema operativo. Pero, ¿qué los hace tan relevantes y por qué son
esenciales en el desarrollo de aplicaciones? En esta introducción, exploraremos en
detalle estos conceptos, su utilidad y algunos aspectos menos conocidos.
Los hilos POSIX forman parte de la especificación POSIX (Portable Operating System
Interface), una norma ampliamente aceptada para interfaces de programación en
sistemas operativos. Su característica distintiva radica en la posibilidad de realizar
múltiples tareas de forma simultánea dentro de un proceso. En otras palabras,
permiten que un programa se ejecute de manera concurrente, lo que implica que
diferentes tareas pueden compartir recursos y datos en un mismo entorno de
programación.
La utilidad de los hilos POSIX es amplia y diversa. En primer lugar, permiten mejorar
el rendimiento de las aplicaciones, lo que es esencial en sistemas con múltiples
procesadores o núcleos. También son cruciales en aplicaciones con interfaces de
usuario interactivas, ya que mantienen la respuesta del programa mientras se
ejecutan tareas en segundo plano, como la carga de datos o el procesamiento de
información. En el ámbito de los servidores y servicios en red, los hilos POSIX son
indispensables para manejar múltiples conexiones de red de manera concurrente, lo
que garantiza una experiencia de usuario eficiente.
En aplicaciones que requieren un alto grado de procesamiento paralelo, como el
análisis de datos o el procesamiento de imágenes, los hilos POSIX pueden dividir el
trabajo en tareas más pequeñas que se ejecutan simultáneamente, lo que acelera
significativamente el rendimiento.
No obstante, los hilos POSIX también tienen aspectos menos conocidos que vale la
pena explorar. Por ejemplo, su portabilidad es una ventaja fundamental. Dado que
siguen un estándar ampliamente aceptado, el código que utiliza hilos POSIX puede
ejecutarse en diversos sistemas operativos sin necesidad de modificaciones
significativas. Esto facilita la reutilización del código en diferentes entornos.
Además, la mayoría de las implementaciones de hilos POSIX se basan en la
biblioteca pthread, que proporciona funciones para crear, gestionar y sincronizar hilos.
Estas funciones son esenciales para garantizar la correcta ejecución de hilos
concurrentes y para evitar problemas de sincronización y condiciones de carrera.

3
 Desarrollo del tema
• Hilos POSIX

Los "Hilos POSIX" son unidades de ejecución más pequeñas que los procesos en un
sistema operativo que permiten realizar tareas concurrentes. En esencia, sirven para
lograr la concurrencia en la programación, lo que significa que múltiples tareas
pueden ejecutarse al mismo tiempo dentro de un programa o proceso. La utilidad de
los hilos POSIX radica en varios aspectos:

o Mejora del Rendimiento: Al permitir que múltiples tareas se ejecuten en paralelo,

los hilos POSIX pueden acelerar el rendimiento de una aplicación. Esto es
especialmente útil en sistemas con múltiples núcleos o procesadores, ya que se
pueden aprovechar al máximo los recursos de hardware disponibles.
o Interfaz de Usuario Receptiva: En aplicaciones con interfaces de usuario, los
hilos POSIX se utilizan para mantener la respuesta del programa mientras se
ejecutan tareas en segundo plano. Esto evita que la interfaz se bloquee o se
vuelva no receptiva, lo que mejora la experiencia del usuario.
o Procesamiento Paralelo: En tareas de procesamiento de datos intensivo o
cálculos complejos, los hilos POSIX permiten dividir el trabajo en tareas más
pequeñas que se ejecutan en paralelo. Esto acelera el tiempo de procesamiento
y mejora la eficiencia.
o Manejo de Conexiones en Red: En aplicaciones de servidor, como servidores
web o de bases de datos, los hilos POSIX se utilizan para manejar múltiples
conexiones de red de manera concurrente. Esto es esencial para garantizar que
el servidor pueda atender a múltiples clientes al mismo tiempo.
o Optimización de Recursos: Los hilos POSIX permiten una utilización más
eficiente de los recursos del sistema. En lugar de ejecutar múltiples procesos
independientes, que consumirían más recursos, los hilos comparten recursos y
datos en el mismo proceso, lo que ahorra memoria y otros recursos.
o Programación Concurrente: Los hilos POSIX son esenciales para la
programación concurrente, donde varias tareas deben ejecutarse de manera
simultánea y coordinada. Esto es común en aplicaciones en tiempo real, sistemas
de control, y más.

4
 Conceptos importantes

Entre los conceptos importantes están:

o Hilo: Un hilo es la unidad más pequeña de procesamiento que puede ser
programada por un sistema operativo. También se le conoce como "proceso
ligero."
o Asincronía/Asincronismo: Se refiere a la capacidad de gestionar eventos de
manera independiente y en momentos diferentes.
o Concurrencia: Es la descripción de cómo se comportan las tareas en un
sistema que consta de un solo procesador. Aunque parecen ocurrir
simultáneamente, en realidad se ejecutan de manera secuencial.
o Monoprocesador: Se refiere a una computadora que tiene una sola unidad de
procesamiento visible para el programador.
o Multiprocesador: Es una computadora con más de dos procesadores que
comparten instrucciones y acceden a un mismo espacio de memoria.
o Paralelismo: Se refiere a secuencias que ocurren simultáneamente, donde dos
o más cálculos se ejecutan al mismo tiempo.
o Overhead: Se define como el tiempo indirecto necesario para llevar a cabo una
ejecución. Es el tiempo adicional que no está directamente relacionado con la
ejecución de la tarea principal.

 Creación de hilos
La creación de hilos es un concepto crucial en programación que permite ejecutar
múltiples flujos de instrucciones de forma concurrente dentro de un programa. Los
hilos son unidades más pequeñas que los procesos y se utilizan para realizar tareas
independientes. La creación de hilos es especialmente útil en aplicaciones donde se
requiere paralelismo, rendimiento y capacidad de respuesta.
Para crear hilos, generalmente se utiliza una biblioteca o conjunto de funciones
proporcionadas por el sistema operativo o el entorno de desarrollo. En sistemas
compatibles con POSIX, como Linux y Unix, se suelen utilizar las bibliotecas pthread
para crear y gestionar hilos. En entornos de desarrollo como Java, se utilizan clases
y métodos específicos para la creación de hilos.
La creación de hilos implica definir la función o el código que se ejecutará en paralelo
en cada hilo. Luego, se inician los hilos y el sistema operativo se encarga de asignar
tiempo de CPU a cada uno de ellos de manera concurrente. Los hilos comparten
recursos y datos con el proceso principal y entre sí, lo que permite la comunicación y
la sincronización.
Es importante tener en cuenta que la programación con hilos requiere precaución, ya
que puede dar lugar a problemas de sincronización y condiciones de carrera si no se
maneja adecuadamente. Por lo tanto, se utilizan mecanismos de sincronización, como
semáforos y mutex, para coordinar el acceso a recursos compartidos y evitar
conflictos.

5
 Creación de hilos en diferentes entornos
La creación de hilos se realiza utilizando bibliotecas o clases específicas
proporcionadas por el sistema operativo o el entorno de desarrollo. La elección de la
biblioteca o el enfoque específico depende del lenguaje de programación y del
sistema operativo que estés utilizando. Aquí hay algunos ejemplos de cómo se crean
hilos en diferentes entornos:

o C/C++ (Sistemas POSIX): En sistemas compatibles con POSIX, como Linux y

Unix, se utiliza la biblioteca pthread (POSIX Threads) para la creación y gestión
de hilos. Se pueden usar las funciones pthread_create para crear un nuevo hilo y
pthread_join para esperar a que termine.
Ejemplo de la creación:

6
o Java: En Java, los hilos se crean utilizando la clase Thread o implementando la
interfaz Runnable.
Ejemplo de la creación:

o Python: En Python, los hilos se crean utilizando el módulo threading.

Ejemplo de la creación:

7
 Atributos
Los hilos, ya sea en C/C++, Java, Python o en otros lenguajes de programación,
pueden tener varios atributos que permiten configurar su comportamiento y
características. Aquí hay algunos de los atributos comunes asociados con los hilos:
o Prioridad del Hilo: La prioridad de un hilo determina qué tan pronto se
programará su ejecución en relación con otros hilos. Algunos sistemas permiten
ajustar la prioridad de un hilo para controlar su orden de ejecución.
o Estado de Bloqueo: Los hilos pueden entrar en un estado de bloqueo cuando
esperan recursos o eventos. El estado de bloqueo es un atributo importante para
el diagnóstico de problemas de concurrencia.
o Tamaño de la Pila: Cada hilo tiene su propia pila de llamadas. El tamaño de la
pila es un atributo que determina cuánta memoria se asigna a la pila del hilo.
Ajustar el tamaño de la pila puede ser crítico para evitar desbordamientos de pila.
o Planificabilidad: En sistemas en tiempo real, se utiliza el atributo de
planificabilidad para determinar si un hilo puede cumplir con sus plazos de
ejecución.
o Identificador de Grupo de Hilos: En algunos sistemas, los hilos pueden
organizarse en grupos para facilitar la gestión y la asignación de recursos.
o Contexto de ejecución: El contexto de ejecución de un hilo incluye registros de
CPU, punteros de pila y otros datos necesarios para su ejecución. Este contexto
se guarda y restaura cuando un hilo se ejecuta o se suspende.
o Memoria asignada: Cada hilo tiene su propio espacio de memoria asignado, que
incluye la pila de llamadas y variables locales. Esto permite que los hilos tengan
datos independientes.

 Terminación de hilo
La terminación de un hilo es un proceso crítico para garantizar una operación segura
y ordenada de los hilos en una aplicación. La finalización de un hilo generalmente se
logra mediante una de las siguientes formas:
o Finalización natural: Un hilo puede finalizar su ejecución cuando ha completado
la tarea que se le asignó. Esto suele ocurrir al llegar al final de la función que se
ejecuta en el hilo. Una vez que se ha realizado el trabajo, el hilo puede finalizar de
manera natural.
o Instrucciones de terminación: A veces, se pueden utilizar instrucciones o
señales específicas para indicar a un hilo que debe finalizar. Por ejemplo, en Java,
puedes usar `Thread.interrupt()` para señalizar a un hilo que debe detenerse. El
hilo debe estar diseñado para responder a estas señales y finalizar de manera
segura.
o Excepciones: Si ocurre una excepción no controlada en un hilo, puede llevar a la
terminación del hilo. Es importante que el hilo maneje adecuadamente las
excepciones para que pueda liberar recursos y finalizar de manera ordenada.

8
o Uso de banderas o variables de estado: Una técnica común es utilizar una
bandera o una variable de estado para indicar si un hilo debe continuar
ejecutándose o si debe finalizar. El hilo verifica periódicamente el valor de esta
bandera y, si se establece en un valor específico, el hilo finaliza.
o Llamada a funciones de finalización: En algunos casos, se puede utilizar una
función específica para indicar que un hilo debe finalizar. Esto puede incluir
funciones como `pthread_exit()` en C/C++ o métodos personalizados en otros
lenguajes.
Es fundamental que la terminación de un hilo se realice de manera ordenada y segura
para evitar problemas de concurrencia y fugas de recursos. Los hilos deben liberar
los recursos que han adquirido, cerrar archivos, liberar memoria y realizar cualquier
otra limpieza necesaria antes de finalizar. Además, es importante sincronizar
adecuadamente la terminación de los hilos con el hilo principal para evitar que el
programa termine antes de que todos los hilos hayan finalizado su trabajo.

 Espera por la terminación de un hilo

La espera por la terminación de un hilo se refiere al proceso en el que el hilo
principal de un programa se detiene temporalmente para permitir que otros hilos
finalicen su trabajo. Esto implica que el hilo principal no continúa su ejecución hasta
que todos los hilos secundarios hayan completado sus tareas o hayan sido
terminados explícitamente. Esta espera puede ser necesaria para garantizar que los
resultados generados por los hilos secundarios estén disponibles y se eviten
problemas de sincronización.

 Cancelación de un hilo
La cancelación de un hilo es un proceso que implica detener un hilo en ejecución de
manera forzada antes de que haya completado su tarea. Esto puede ser necesario
en situaciones donde un hilo queda atrapado en un bucle infinito o experimenta un
comportamiento no deseado que no se puede manejar de manera normal.
La cancelación de un hilo generalmente se logra a través de señales o métodos
específicos proporcionados por la plataforma o el lenguaje de programación que
permiten indicar que un hilo debe detenerse. El hilo debe estar diseñado para
responder a estas señales y finalizar de manera segura.
Es importante tener en cuenta que la cancelación de hilos debe manejarse con
precaución, ya que puede llevar a problemas de sincronización y dejar recursos en
un estado inconsistente. Por lo tanto, debe realizarse con cuidado y solo cuando sea
necesario para evitar problemas en la aplicación.

9
 Ejemplo

import threading

import time

def calcular_resultado(inicio, fin):

resultado = 0

for i in range(inicio, fin):

resultado += i

return resultado

def procesar_rango(inicio, fin, resultados):

print(f"Hilo procesando el rango {inicio}-{fin}")

resultado = calcular_resultado(inicio, fin)

resultados.append(resultado)

print(f"Hilo terminó de procesar el rango {inicio}-{fin}")

num_hilos = 4

resultados = []

hilos = []

for i in range(num_hilos):

inicio = i * 25 + 1

fin = (i + 1) * 25 + 1

hilo = threading.Thread(target=procesar_rango, args=(inicio, fin, resultados))

hilos.append(hilo)

hilo.start()

for hilo in hilos:

hilo.join()

resultado_final = sum(resultados)

print(f"Resultado final: {resultado_final}")

10
  Conclusión

Los hilos POSIX, una característica esencial en la programación concurrente,

desempeñan un papel fundamental en la gestión eficiente de recursos y la mejora del
rendimiento de las aplicaciones. En esta conclusión, exploraremos los aspectos clave
relacionados con los hilos y su impacto en la programación.
Los hilos permiten la ejecución simultánea de tareas dentro de un proceso, lo que
resulta en un uso más eficiente de la CPU y una mayor capacidad de respuesta en
las aplicaciones. Al dividir una aplicación en hilos, es posible realizar múltiples tareas
en paralelo, lo que es especialmente beneficioso en aplicaciones que requieren
procesamiento intensivo, como la manipulación de datos, cálculos matemáticos o
interacción con la interfaz de usuario.
Una ventaja importante de los hilos es su capacidad para compartir memoria y
recursos dentro del mismo proceso. Esto permite una comunicación y una
cooperación más sencillas entre los hilos, lo que simplifica la implementación de
tareas concurrentes. Sin embargo, esta ventaja puede convertirse en un desafío si no
se maneja adecuadamente, ya que la compartición de recursos puede dar lugar a
problemas de concurrencia, como condiciones de carrera y bloqueos.
La sincronización es esencial en la programación con hilos. Los programadores deben
garantizar que los hilos se ejecuten de manera ordenada y que los recursos
compartidos se utilicen de manera segura. Se utilizan diversos mecanismos de
sincronización, como semáforos, mutex (exclusión mutua) y variables de condición,
para evitar conflictos y garantizar la coherencia de los datos.
El concepto de hilos no se limita a la programación en un solo lenguaje o plataforma.
Los hilos se utilizan en una variedad de lenguajes de programación, como C/C++,
Java, Python y otros, y están disponibles en sistemas operativos como Linux,
Windows y macOS. Esto hace que los hilos sean una herramienta versátil y
ampliamente aplicable en el desarrollo de software.
No obstante, los hilos también presentan desafíos y consideraciones importantes. La
gestión de hilos requiere una comprensión sólida de la concurrencia y la
sincronización, lo que puede ser complicado. Los errores en la programación con hilos
pueden llevar a problemas de rendimiento, bloqueos y errores difíciles de depurar.
Además, es crucial equilibrar la cantidad de hilos en una aplicación. Demasiados hilos
pueden aumentar la sobrecarga del sistema y disminuir el rendimiento debido al
cambio de contexto. Por otro lado, muy pocos hilos pueden subutilizar los recursos
del sistema.

11
  Bibliografias

Operativos, S. (s/f). Hilos de ejecución POSIX. Uva.es. Recuperado el 22 de octubre

de 2023, de

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

González, A. J. (s/f). POSIX Threads. Utfsm.cl. Recuperado el 22 de octubre de 2023,

de

http://profesores.elo.utfsm.cl/~agv/elo330/2s06/lectures/POSIX_threads/P

OSIX_Threads.html

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

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

para-gestion-de-hilos/

12