2021

FORO 1

Nombre: Antonio Perez Jr

Matrícula: A0136522033.

Unidad I: Subprocesamiento múltiple.

Fecha: 14 de Abril del 2021.

..
Índice
Introducción..................................................................................................................................... 1
Primer Aspecto ............................................................................................................................... 2
Segundo Aspecto ........................................................................................................................... 2
Tercer Aspecto ................................................................................................................................ 7
Referencias ...................................................................................................................................... 8

Ilustraciones
Ilustración 1 Ciclo de vida de un thread. ............................................................................................. 1
Ilustración 2 Clase Hilo. ....................................................................................................................... 3
Ilustración 3 Clase HiloEspera. ............................................................................................................ 3
Ilustración 4 Clase HiloRunnable. ........................................................................................................ 3
Ilustración 5 Clase HiloEsperaRunnable. ............................................................................................. 4
Ilustración 6 Clase principal ThreadHolaMundo. ................................................................................ 5
Ilustración 7 Resultados del Aspecto 2. .............................................................................................. 6

Figuras
Figura 1 Beneficios de utilizar el subprocesamiento múltiple (threads) en el desarrollo programas. 2
Figura 2 Resultado del Aspecto 3. ....................................................................................................... 7
Introducción
Para realizar los siguientes aspectos de este foro, necesitaremos entender y
comprender que es un Thread.

“Es un proceso que ha sido lanzado desde otro proceso (el programa) y que
ejecutará una secuencia de acciones concurrentemente a la ejecución del
programa que lo lanzó” (Sznajdleder, 2013, p.200).

“Es básicamente un peso ligero y la unidad de procesamiento más pequeña.

Java usa subprocesos utilizando una clase de subprocesos” (Guru 99, 2021).

Un Thread cuenta con un ciclo de vida, esto va desde que es instanciado y

ejecutado, pasando por diversos estados hasta que finalmente muere. Un
ejemplo claro es el siguiente:

Ilustración 1 Ciclo de vida de un thread.

Nota. Recuperado de “Java a fondo. Estudio del lenguaje y desarrollo de aplicaciones”, de

Sznajdleder, P. A., 2013, p.207, Distrito Federal: Alfaomega Grupo Editor.

Ahora que ya tenemos más conocimiento sobre el tema comencemos

aplicarlo en los siguientes aspectos.

1
Primer Aspecto
¿Cuáles son los beneficios de utilizar el subprocesamiento múltiple
(threads) en el desarrollo programas para las organizaciones?

Evita que se
Independencia de interrumpa o se
recursos. relenticen los
procesos.

Ejecución de varios
procesos en
paralelo.

Mayor rendimiento.

Figura 1 Beneficios de utilizar el subprocesamiento múltiple (threads) en el desarrollo programas.

Segundo Aspecto
Implemente un programa que escriba un “hola mundo” por cada hilo de
ejecución que se cree (seis es un número razonable) y que además
indique desde que hilo se imprime. Luego haga que cada uno espere un
tiempo proporcional a su identificador antes de imprimir el mensaje (el
thread 1, un segundo, el 2, dos segundos, el 3, tres segundos,…). Lance
los threads mediante la clase Thread y luego mediante el interfaz
Runnable ¿Qué diferencias aprecia?

Se crea la clase Hilo, HiloEspera, HiloRunnable y HiloEsperaRunnable:

2
 Ilustración 2 Clase Hilo.

Ilustración 3 Clase HiloEspera.

Ilustración 4 Clase HiloRunnable.

3
 Ilustración 5 Clase HiloEsperaRunnable.

Posteriormente se crea la clase principal ThreadHolaMundo:

4
 Ilustración 6 Clase principal ThreadHolaMundo.

Resultados:

Clase Hilo

Clase
HiloEspera

5
 Clases

HiloRunnable y
HiloEsperaRunnable

Ilustración 7 Resultados del Aspecto 2.

Las diferencias que se aprecian entre Runnable y Thread son:

 Runnable es una interfaz en Java para crear un hilo que permite que
muchos hilos compartan el mismo objeto de hilo. Thread es una clase
en Java para crear un hilo en el que cada hilo tiene un objeto único
asociado a él.
 En Runnable varios subprocesos comparten el mismo objeto, lo que
lo hace más eficiente. Mientras que la clase Thread es menos
eficiente.
 Runnable puede extender una clase. Pero la clase Thread no puede
extender de ninguna otra clase después de ella, esto se debe a la
restricción que pone Java en no admitir múltiples herencias.
 Como Runnable es una interfaz hace que el código sea más fácil de
mantener. Mientras que el mantenimiento para la clase Thread
requiere más tiempo.

6
Tercer Aspecto
Resuelve el siguiente ejercicio relacionado con el lenguaje de
programación orientada a objetos:

What is the result of this

code?
Given: A. Compilation fails
class MyThread extends Thread { B. 1..2..3..
public static void main(String[] args) { C. 0..1..2..3..
MyThread t = new MyThread(); D. 0..1..2..
Thread x = new Thread(t); E. An exception occurs at
x.start(); runtime

La respuesta correcta
public void run() { es la

for (int i = 0; i < 3; ++i) { D. 0..1..2..

System.out.print(i + "..");

Figura 2 Resultado del Aspecto 3.

7
Referencias
CoreDump. (2021). ¿Cuáles son las ventajas de utilizar un ExecutorService?
Obtenido de CoreDump: https://es.coredump.biz/questions/3984076/what-
are-the-advantages-of-using-an-executorservice
Guru 99. (2021). Multithreading en Java Tutorial con ejemplos. Obtenido de Guru
99: https://guru99.es/multithreading-java/
Joyanes Aguilar, L., & Zahonero Martínez, I. (2011). Programación en Java:
algoritmos, programación orientada a objetos e interfaz gráfica de usuarios.
Distrito Federal: McGraw-Hill Interamericana.
Sznajdleder, P. A. (2013). Java a fondo. Estudio del lenguaje y desarrollo de
aplicaciones. Distrito Federal: Alfaomega Grupo Editor.
Videoconferencias UTPL. (13 de Enero de 2013). Subprocesamiento Mùltiple.
Obtenido de Videoconferencias UTPL:
https://es.slideshare.net/videoconferencias/video-6-16058588