Sistemas Operativos Distribuidos 2021-II
Docente M.Sc. Crisóstomo Barajas
TALLER REVISIÓN HILOS
Septiembre 22 de 2021
El siguiente es un taller calificable para la revisión y refuerzo de conceptos previo al segundo parcial del curso de
Sistemas Operativos Distribuidos 2021-II. Por favor, presente el desarrollo de este taller en formato digital (PDF,
documento editable, imagen, etc.) con sus respuestas de manera legible para su evaluación.
1. Ingrese a la página https://dotnetfiddle.net/ y copie/peque el contenido del archivo adjunto Metodo1.txt. Asegúrese
de escoger el compilador .NET 5 y el lenguaje Csharp
a) ¿Qué hace el método DoSomeHeavyLifting?
Escribe una línea de código en consola apenas se invoca, y luego cada 1 segundo escribe líneas de código indicando que
le den “3 segundos para arrancar”, y por ultimo dice que ya está listo.
b) ¿Qué hace el método DoSomething()?
Escribe 2 lineas de código en consola y luego escribe hace pasos escribiendo de 0 hasta 19 de uno en 1, y
posteriormente escribe que ya acabo.
c) ¿Por qué ambos métodos son static?
Dado que el método Main es static, para invocarlos desde allí deben tener la misma estructura en este caso static void.
d) Incluya una captura de pantalla de la ejecución de ese código.
e) ¿En cuál momento acaba el método DoSomeHeavyLifting? ¿En cuál momento acaba el método DoSomething? ¿En
cuál momento acaba el método Main?
Al arrancar el método main que es el principal escribe una línea en consola, y luego crea un hilo llamando anexándole el
método DoSomeHeavyLifting el cual es llamado con el backgroundThread.Start() y escribe una línea en consola, luego
arranca el método DoSomething escribe todas sus líneas en consola y ahí termina, luego el metodo Main escribe la
ultima linea en consola y también termina, y posterior continua el método DoSomeHeavyLifting escribiendo sus líneas
con los intervalos de tiempo.
f) ¿Por qué la diferencia en los tiempos de finalización?
Dado la función “.Sleep()” del Thread, ya que dependiendo del valor que se le ingrese en milisegundos toma un tiempo
de reposo. Es por eso que el método DoSomeHeavyLifting cuando se invoca con el backgroundThread.Start(), requiere
más tiempo que el metodo Main y el DoSomething.
g) La instrucción backgroundThread.Join() obliga a la ejecución del hilo Main a esperar a que termine la ejecución del
hilo backgroundThreat antes de continuar. Inserte la línea backgroundThread.Join() en el lugar más conveniente tal
que el hilo Main sea el ultimo en terminar. Agregue una captura del código Main modificado y el resultado obtenido.
2. Ingrese a la página https://dotnetfiddle.net/ y copie/peque el contenido del archivo adjunto Metodo2.txt. Asegúrese
de escoger el compilador .NET 5 y el lenguaje Csharp
a) Consulte en internet: ¿Qué hace el ThreadPool?
Proporciona un conjunto de subprocesos que se pueden utilizar para ejecutar tareas, publicar elementos de trabajo,
procesar E / S asincrónicas, esperar en nombre de otros subprocesos y procesar temporizadores.
b) ¿Cuál de todos los hilos, incluido el Main, SIEMPRE acaba primero? ¿Por qué?
El hilo main, dado que se crean varios hilos y tienen un sleep de 10 milisegundos.
c) Explique las líneas 22 y 23 del código
En la linea 22 le asigna al atributo oper (que es un array de la clase operaciones, de 6 posiciones), la clase operaciones
pero ya en una posición definida por el for, y le envía adicionalmente un numero basado en el array de valores en la
posición que el for indique.
En la linea 23 ejecuta un ThreadPool o un subproceso, que espera un callback que es decir una devolución de un
método, el cual es el atributo oper en la posición i dependiendo del for, y como es una clase llamada al método
potencia.
d) Cree el método Sumatoria() para calcular la sumatoria desde 1 hasta un numero n, siguiendo la misma lógica de
diseño. Agregue una captura de pantalla del nuevo método, del método Main modificado y del resultado del código.
3. Ingrese a la pagina https://dotnetfiddle.net/ y copie/peque el contenido del archivo adjunto Metodo3.txt. Asegúrese
de escoger el compilador .NET 5 y el lenguaje Csharp.
a) Compare el método Operaciones. Potencia del archivo adjunto Metodo2.txt vs Metodo3.txt. Resalte las diferencias
e intuya su funcionamiento.
Las diferencias visibles a priori son 2 lineas de código en el Metodo3.txt que son:
- ManualResetEvent waitHandleFromParent = (ManualResetEvent)state;
- waitHandleFromParent.Set();
Supongo que el primero crea un atributo waitHandleFromParent que viene de una clase ManualResetEvent mas
apropiadamente de un state, posteriormente se invoca un metodo de esa clase llamada set(); lo que intuyo es que
espera que el conjunto de subprocesos acaben por completo para seguir el metodo main.
b) En las líneas 27 y 28 se crea un segundo ciclo For para llamar al método WaitOne(). ¿Qué sucede si estas
invocaciones se realizan dentro del ciclo For principal? Agregue una captura de pantalla del resultado.
c) En base al resultado anterior, ¿cuál es la función del método WaitOne?
Espera que el subproceso termine para arrancar el siguiente.
d) Explique, en sus propias palabras, lo que sucede desde la línea 19 hasta la 28 (del código original) y en el método
Operaciones. Potencia.
Básicamente es lo mismo que el anterior Metodo2.text, la única diferencia es la clase ManualResetEvent que tiene una
serie de método que se usan, en este caso se usa el WaitOne, al mismo tiempo el atributo que se crea se envía como
parámetro al WaitCallback para que también se ejecute; todo esto hacer que el main no finalice hasta que el conjunto
de procesos finalice su procedimiento.
e) Los códigos incluidos en Metodo2.txt y Metodo3.txt ambos usan el ThreadPool para organizar la ejecución de los
hilos creados manualmente. ¿Cuál es la principal diferencia entre ambos códigos?
La principal diferencia es el metodo WaitOne de la clase ManualResetEvent que controla la terminación del ThreadPool,
en este caso para el Metodo3.txt el main no termina hasta que se ejecute todo el código dentro del for, y si se hace la
modificación del punto B, hace que un subproceso no arranque hasta que el otro haya terminado.
