Introducción al paralelismo - hilos

En el presente repositorio se realiza un análisis de los hilos en Java. Estos son unidades ligeras de ejecución que permiten realizar múltiples tareas de manera concurrente dentro de un mismo programa. Comparten el mismo espacio de memoria del proceso, requiriendo mecanismos de sincronización para evitar problemas en su desarrollo.

Páginas HTML Archivos JavaScript Hojas de estilo CSS Imágenes Este ejercicio permitirá comprender cómo un servidor procesa peticiones y sirve contenido estático de manera eficiente.

Comenzando 🚀

Las siguientes instrucciones le permitirán obtener una copia del proyecto en funcionamiento en su máquina local para fines de desarrollo y prueba.

Requisitos ⚙️

• Java - Desarrollo

Instalación 📦

Realice los siguientes pasos para clonar el proyecto en su máquina local.

git clone https://github.com/Pau993/TalleARSW.git
git checkout TalleARSW

El anterior comando limpiará las contrucciones previas, compilará y empaquetará el código en un jar y luego ejecutará la aplicación.

Descripción de la aplicación 📖

Parte I: Hilos en Java

1. De acuerdo con lo revisado en las lecturas, complete las clases CountThread para que definan el ciclo de vida de un hilo que imprima por pantalla los números entre A y B.

   • Explicación: En el constructor se reciben los límites A y B (A inferior del rango, B superior del rango), permitiendo crear un hilo con un rango específico.
   • En el método run(), se sobrescribe el método de la clase Thread. Si A es mayor que B, se intercambian los valores e imprime los números entre A y B (excluyendo estos mismos).

   Fragmento de código:

2. Complete el método main de la clase CountMainThreads para que:

   1. Cree 3 hilos de tipo CountThread, asignándole al primero el intervalo [0..99], al segundo [99..199] y al tercero [200..299].
   2. Inicie los tres hilos con start().
   3. Ejecute y revise la salida por pantalla.

   Salida:

   4. Cambie el inicio con start() por run(). ¿Cómo cambia la salida y por qué?
   • No existe paralelismo, ya que el código se ejecuta de forma secuencial. El tiempo de ejecución es similar a un solo hilo, perdiendo el beneficio de concurrencia.

   Fragmento de código:

Parte II: Hilos en Java

Para este ejercicio se quiere calcular, en el menor tiempo posible, al menos el primer millón de dígitos de PI (en base 16) en una sola máquina, aprovechando las características multi-core.

1. Cree una clase de tipo Thread que represente el ciclo de vida de un hilo que calcule una parte de los dígitos requeridos. Fragmento de código:

   • Se generan los atributos donde tendrá su punto de inicio, la cantidad de dígitos a calcular y el array.
   • El método run() recalcula la suma cada DigitsPerSum iteraciones y realiza el cálculo del dígito hexadecimal.

2. Haga que la función PiDigits.getDigits() reciba como parámetro adicional un valor N, correspondiente al número de hilos entre los que se va a paralelizar la solución. Haga que dicha función espere hasta que los N hilos terminen de resolver el problema para combinar las respuestas y retornar el resultado.

   • Se modifica el método principal para soportar múltiples hilos, calculando el tamaño de cada chunk y creando un arreglo para almacenar los hilos.

   Fragmento de código:

3. Ajuste las pruebas de JUnit, considerando los casos de usar 1, 2 o 3 hilos (este último para considerar un número impar de hilos).

   • En el ajuste de las pruebas se adecúa para los diferentes hilos, además de incluir una salida para ver el proceso de cada uno de los hilos.

   Salida de las pruebas:

Parte III: Evaluación de Desempeño

A partir de lo anterior, implemente la siguiente secuencia de experimentos para calcular el millón de dígitos (hex) de PI, tomando los tiempos de ejecución:

1. Un solo hilo.

2. Tantos hilos como núcleos de procesamiento (haga que el programa determine esto usando el API Runtime).

3. Tantos hilos como el doble de núcleos de procesamiento.

4. 200 hilos.

5. 500 hilos.

   • Para la implementación se creó PiDigitsPerformanceTests, donde se verifica el rendimiento con configuraciones variadas de hilos. Se determina el número de núcleos del procesador y se define un arreglo con 1 núcleo, doble núcleo, 200 y 500. Luego se itera sobre estas configuraciones, ejecutando el millón de dígitos hexadecimales de Pi. En cada configuración se mide el tiempo de ejecución con System.nanoTime(), convirtiéndolo a milisegundos y luego se imprimen los resultados.

   Fragmento de código:

Al iniciar el programa, ejecute el monitor jVisualVM y anote el consumo de CPU y de memoria en cada caso.

• Código modificado:

Resultados de Ejecución:

• 1 hilo:

  

• 16 hilos (núcleos de procesamiento):

  

• 32 hilos:

  

• 200 hilos:

  

• 500 hilos:

  

Con lo anterior y los tiempos de ejecución dados, se realiza una gráfica de tiempo de solución vs. número de hilos.

Gráfica tiempo de solución vs. número de hilos:

• 

Análisis de Resultados

1. Ley de Amdahl:

   • Según la ley de Amdahl, el mejor desempeño no se logra con 500 hilos debido a la sobrecarga en la gestión de hilos. Esto provoca cuellos de botella por competencia por recursos. El mejor desempeño se logra con 32 hilos (335 ms), y con 200 se degrada levemente (352 ms), mientras que con 500 hilos el tiempo aumenta (382 ms).

2. Comparación de núcleos vs. hilos:

   • Con 16 núcleos (tiempo de ejecución 411 ms) y el doble (32 hilos, 335 ms), se muestra ineficiencia con 16 hilos debido a la competencia por recursos.

3. Uso de múltiples máquinas:

   • Ejecutar 500 hilos en una máquina no es eficiente. Utilizar múltiples máquinas distribuyendo el trabajo puede mejorar el rendimiento.

Autores ✒️

• *Paula Natalia Paez Vega y Manuel Felipe Barrera Barrera

Licencia 📄

This project is licensed under the MIT License