Hilos con Java

Jorge Alberto Pinzón Pataquiva

2010650218

Politécnico Gran Colombiano

Elementos de Teoría de Computación

Facultad de Ciencias básicas

Bogotá, Colombia 2020

pág. 1
 Hilos con Java

Jorge Alberto Pinzón Pataquiva

Taller Hilos

Docente
Victor Agusto Pedraza Bonilla

Politécnico Gran Colombiano

Elementos de Teoría de Computación

Facultad de Ciencias básicas

Bogotá, Colombia 2020

pág. 2
 Resumen

En este documento se explica brevemente como desarrollar un programa en el lenguaje

Java que permite crear 3 hilos, los cuales deben realizar las series Fibonacci y Factorial

según la cantidad de iteraciones ingresadas por el usuario, estos hilos ejecutan de

manera simultánea lo que permite que los cálculos de las series se lleven a cabo por

separado.

Se hace uso de la interfaz Runnable de Java para proporcionar a las clases Hilo1,

Hilo2 e Hilo3 capacidad de ser hilos , además se hace de los objetos BigInteger para

poder calcular valores extremadamente grandes, en particular para la seria Factorial,

además se explica paso a paso como se concibe la solución del problema planteado.

Abstract
This document briefly explains how to develop a program in the Java language that

allows creating 3 threads, which must perform the Fibonacci and Factorial series

according to the number of iterations entered by the user, these threads execute

simultaneously which allows the series calculations are carried out separately.

The Java Runnable interface is used to provide the Hilo1, Hilo2 and Hilo3 classes with

the ability to be threads, in addition to BigInteger objects to be able to calculate

extremely large values, in particular for the Factorial series, it is also explained step by

step as the solution of the problem is conceived..

pág. 3
Contenido

Objetivos ....................................................................................................................................... 5
General ...................................................................................................................................... 5
Específicos ................................................................................................................................. 5
Lenguaje Java ................................................................................................................................ 5
El compilador Java ..................................................................................................................... 6
La JVM ....................................................................................................................................... 6
Estructura del programa ............................................................................................................... 6
Explicación del código ................................................................................................................... 7
Método main ............................................................................................................................. 7
Instanciar las clases hilo ............................................................................................................ 8
Definición de las clases Hilo1, Hilo2 e Hilo3 .............................................................................. 9
La interfaz Runnable................................................................................................................ 12
La clase que realiza el trabajo sucio ........................................................................................ 12
Atributos privados ............................................................................................................... 13
Métodos de la clase padre .................................................................................................. 13
Ejecución ..................................................................................................................................... 17
Resultados ................................................................................................................................... 20
Bibliografía .................................................................................................................................. 21

pág. 4
Objetivos

General

Desarrollar una aplicación en el lenguaje Java que permita crear 3 hilos donde el

usuario puede ingresar un numero de cualquier tamaño (por ejemplo 10 o

100000000000) el cual será la cantidad de iteraciones que tendrá la sucesión a realizar,

Por medio de creación de tres Hilos (Threads) el programa debe hacer lo siguiente

Hilo 1 : debe realizar la sucesión de Fibonacci

Hilo 2: debe realizar la sucesión de factorial

Hilo 3 : debe realizar una sucesión elegida por el estudiante

Específicos

• Desarrollar un sistema en el lenguaje Java que permite crear 3 hilos y se ejecuten

en paralelo.

• Crear una interfaz para que el usuario ingrese la cantidad de la seria y la

operación a realizar.

• Validar como a un hilo se ejecuta en forma paralela dentro de un programa en

Java.

Lenguaje Java

(Perry, 2012) La tecnología Java se usa para desarrollar aplicaciones para un

amplio alcance de entornos, desde dispositivos del consumidor hasta sistemas

empresariales heterogéneos. En esta sección, obtenga una vista de alto nivel de la

plataforma Java y sus componentes. Vea Recursos para aprender más acerca de los

componentes de la plataforma Java discutidos en esta sección.

pág. 5
El compilador Java

(Perry, 2012) Cuando usted programa para la plataforma Java, escribe el

código de origen en archivos .java y luego los compila. El compilador verifica su

código con las reglas de sintaxis del lenguaje, luego escribe los códigos byte en

archivos .class. Los códigos byte son instrucciones estándar destinadas a ejecutarse

en una Java Virtual Machine (JVM)

La JVM

(Perry, 2012) La JVM lee e interpreta archivos .class y ejecuta las

instrucciones del programa en la plataforma de hardware nativo para la que se

escribió la JVM. La JVM interpreta los códigos byte del mismo modo en que una

CPU interpretaría las instrucciones del lenguaje del conjunto. La diferencia es que la

JVM es un software escrito específicamente para una plataforma particular. La JVM

es el corazón del principio «escrito una vez, ejecutado en cualquier lugar» del

lenguaje Java.

Estructura del programa

El programa este compuesto por 3

paquetes, estos paquetes son images,

threads e hilos.

Se definen 4 clases, 3 de las cuales

son los hilos que serán ejecutados y

una cuarta clase que se define como

clase padre de las 3 clases

anteriormente mencionadas con el fin

de centralizar las operaciones.

pág. 6
Explicación del código

Método main

Ilustración 1 Método main

En el método main se procede a instanciar la clase base para poder proporcionar una

entrada al usuario, esta se lleva a cabo desde el método inputUser, el cual genera un

pág. 7
JOptionPane.showInputDialog para ingresar la cantidad de iteraciones que tendrá las

serie y regresa un (Caules, 2014) BigInteger para que se tome en los hilos.

Ilustración 2 Método inputUser que proporciona entrada al usuario

Ilustración 3 Interfaz de entrada para el usuario

Se define BigInteger como tipo de dato para la cantidad de sería ya que puede

ser un valor de 1 hasta 100000000000 por lo que un tipo de dato primitivo con int o

long no proporciona una cantidad suficiente de caracteres.

Instanciar las clases hilo

Una vez que se define la cantidad de iteraciones se procede a crear los objetos de

la clase hilo1 e hilo 2 que se encargan de las operaciones Fibonacci y factorial

respectivamente. Para crear un objeto de estas clases se utiliza el constructor, como se

muestra la imagen

Ilustración 4 Creación de los objetos de las clases Hilo1 e Hilo2

pág. 8
Definición de las clases Hilo1, Hilo2 e Hilo3

Ilustración 5 Definición de la clase Hilo1

Como se observa en la ilustración 5 Definición de la clase Hilo1, esta clase

únicamente define el constructor y un método llamada run que indica el inicio del hilo

encargado de la serie Fibonacci.

Esta clase se convierte en una clase hijo ya que se extiende de la clase MisHilos

como se observa en línea 15.

El método run además hace llamado al método operación que está en la clase

padre y se encarga de realizar una serie, bien sea Fibonacci o factorial.

pág. 9
 Ilustración 6 Definición de la clase Hilo 2

Como se observa en la ilustración 6 Definición de la clase Hilo2, esta clase

únicamente define el constructor y un método llamada run que indica el inicio del hilo

encargado de la serie Factorial.

Como se observa esta clase es muy similar a la clase Hilo1 , con la única

diferencia que esta se encarga de realizar la operación factorial, como podemos observar

en la línea 28, donde se indica el inicio de la operación.

Al igual que la clase Hilo1, también es una clase hija de la clase padre MisHilos.

pág. 10
 Ilustración 7 Definición clase Hilo3

Como se observa en la ilustración 7 Definición de la clase Hilo3, esta clase

únicamente define el constructor y un método llamada run que indica el inicio del hilo

encargado de la serie seleccionada por él usuario.

Como se observa esta clase es muy similar a la clase Hilo1 e Hilo2 , con la

diferencia que esta puede realizar bien sea la serie Fibonacci o Factual, según su

atributo tipoOperacion (se le da valor en main, a través de la selección del usuario).

pág. 11
 Al igual que la clase Hilo1 e Hilo2, también es una clase hija de la clase padre

MisHilos.

La interfaz Runnable

La interfaz Runnable en Java permite la creación de hilos y la

interfaz Runnable exige solamente el método run(), el método run() es público.

Esta interfaz permite la creación de un hilo en java de manera muy sencilla, por

lo que las clases Hilo1, Hilo2 e Hilo3 la implementan. Simplemente con sobrescribir el

método run las clases se convierten en hilos dentro de la ejecución del programa.

La clase que realiza el trabajo sucio

Ilustración 8 Clase padre

pág. 12
Como se observa en la anterior imagen se aprecia que esta clase padre contiene 8

métodos, y tres atributos privados.

Atributos privados

tipoOperacion: Permite establecer el tipo de operación que un Hilo va a

realizar, es decir si se establece en 0, el hilo ejecuta la serie Fibonacci, en caso de ser 1,

el hilo realiza la serie factorial.

cantidadSerie: Define la cantidad de iteraciones que un hilo debe realizar en

una serie, bien sea Fibonacci o Factorial, este dato se toma en el main desde la entrada

de usuario.

Ref: Permite incrementar en 1 los objetos de la clase BigInteger, ya que dichos

objetos no admiten operadores primitivos, es por ello que esta variable y el método

incrementAndGet realizan esta acción necesaria en las series Fibonacci y Factorial.

Los atributos anteriormente mencionados hacen parte de las tres clases hija,

desde el momento que se define el extends a la clase padre, con este se logra disminuir

la cantidad de líneas.

Métodos de la clase padre

inputUser: Explicado anteriormente.

opcionUsuario: Este método provee una lista desplegable para que el usuario

seleccione la serie a realizar.

Ilustración 9 Método para seleccionar una serie

pág. 13
 Retorna un String que contiene el nombre de la serie, es decir la palabra

Fibonacci o Factorial, este return se toma en el main y se evalúa que serie debe realizar

el hilo 3.

Ilustración 10 Evaluar la serie a realizar por el hilo 3

Como se observa en la línea 46 de la ilustración 10 , cuando el usuario

selecciona la serie Fibonacci desde la lista desplegable se le setea el valor 1 en el

atributo tipoOperacion, en caso de seleccionar Factorial se setea el valor en 0 con el fin

de realizar la serie correspondiente.

setTipoOperacion: Este método permite establecer el valor que define el tipo de

serie a realizar, admite un entero (1 o 0) para definir el tipo de operación a realizar por

un hilo.

getTipoOperacion: Este método permite obtener el valor del tipo de operación

dentro de una clase, permitiendo mantener el principio de abstracción.

Operación: Este método se encarga de realizar la lógica de la serie , bien sea

Fibonacci o Factorial, por lo tanto, es el core del programa.

pág. 14
 Ilustración 11 Método base del programa

En este método se define los bucles que permite obtener el resultado de una

serie, como las variables son de tipo BigInteger se debe implementar lo métodos

compareTo en lugar de igual (=), el método multiply en lugar de la multiplicación (*), el

método incrementAndGet para incrementar en uno el número de iteración.

Fibonacci: El método Fibonacci es una función recursiva clásica adaptada para

trabajar con BigInteger, pero manteniendo el mismo principio.

pág. 15
 Ilustración 12 Recursividad Fibonacci

esperarXsegundos: Este método se utiliza para dar una espera de dos

milisegundos al hilo de la clase 3 solo cuando ejecuta la serie factorial, puesto que es

una serie mucho más rápida que la Fibonacci.

Para dar espera en un hilo se utiliza la sleep de la clase interfaz Runnable.

Ilustración 13 Dormir un Hilo en Java

incrementAndGet: Este método permite aumentar en 1 un objeto de la clase

BigInteger, puesto que estas clases no permiten el uso de los operadores aritméticos,

lógicos ni relacionales en sus valores, ya que es imposible comparar una referencia del

objeto con un valor de un dato o variable.

pág. 16
Ejecución

Para iniciar el programa debe compilar el mismo bien sea directamente desde la

línea de comandos con Javac o con un editor para Java, este caso se opta por la opción 2

y el editor Netbeans.

Ilustración 14 Programa en ejecución

Al iniciar el sistema solicita ingresar la cantidad de iteraciones para las series, y

es posible observar como el hilo principal ya está en ejecución , pero hasta este

momento aún no se ha creado ningún Hilo definido en las clases.

Una vez ingresado el valor para las iteraciones el sistema, solicita seleccionar la

serie a realizar, en este caso se observa que los dos hilos de la clase Hilo1 e Hilo2 ya

están en ejecución al igual que el hilo principal del programa.

pág. 17
 Ilustración 15 Ejecución de hilos en paralelo

Como se observa en las anteriores imágenes los hilos se ejecutan en paralelo,

esto se aprecia ya que el hilo principal del programa solicita seleccionar una serie a

través del JOptionPane.showInputDialog mientras que el hilo de Fibonacci continúa

calculando el valor de la serie y el hilo de factorial ya termino su ejecución.

pág. 18
 Para continuar con la ejecución del tercer hilo se debe seleccionar una serie

desde la opción, en este caso se selecciona factorial.

Dando por finalizado los 3 hilos y el hilo principal del programa.

pág. 19
Resultados

pág. 20
Bibliografía

Caules, C. Á. (22 de 10 de 2014). Blog sobre Java EE. Obtenido de

https://www.arquitecturajava.com/java-biginteger/

Perry, S. (12 de 03 de 2012). Conceptos básicos del lenguaje Java. Obtenido de

https://developer.ibm.com/es/technologies/java/tutorials/j-introtojava1/

Ramírez, L. V. (21 de Noviembre de 2017). https://bogota.gov.co. Obtenido de

https://bogota.gov.co/encuentra-informacion-actualizada-sobre-el-clima-de-la-ciudad-
de-bogot

pág. 21